maka-agent 0.2.0-dev.4.20260830 → 0.2.0-dev.41.20260918

package/node_modules/@larksuiteoapi/node-sdk/lib/index.js

@@ -297,11 +297,17 @@ const formatDomain = (domain) => {
     }
 };
 
-const fillApiPath = (apiPath, pathSupplement = {}) => apiPath.replace(/:([^/]+)/g, (_, $1) => {
-    if (pathSupplement[$1] !== undefined) {
-        return pathSupplement[$1];
+const fillApiPath = (apiPath, pathSupplement = {}) => 
+// Only treat `:name` as a path parameter when it starts a path segment
+// (string start or right after `/`). Colons inside the URL authority,
+// e.g. `http://localhost:3000` or `user:pw@host`, must be left untouched.
+// The separator is captured and re-emitted instead of using a lookbehind
+// because the compile target (es6) has no lookbehind support.
+apiPath.replace(/(^|\/):([^/]+)/g, (_, pathPrefix, pathKey) => {
+    if (pathSupplement[pathKey] !== undefined) {
+        return `${pathPrefix}${pathSupplement[pathKey]}`;
     }
-    throw new Error(`request miss ${$1} path argument`);
+    throw new Error(`request miss ${pathKey} path argument`);
 });
 
 const assert = (predication, callback) => __awaiter(void 0, void 0, void 0, function* () {
@@ -101978,6 +101984,14 @@ class DataCache {
     }
     mergeData(params) {
         const { message_id, sum, seq, trace_id, data } = params;
+        // Guard against malformed fragment metadata: an invalid `sum` makes
+        // `new Array(sum)` throw (RangeError), and a `seq` outside [0, sum)
+        // would create sparse holes that silently corrupt the merged buffer
+        // (JSON.parse then fails and the event is lost).
+        // See https://github.com/larksuite/node-sdk/issues/201
+        if (!Number.isInteger(sum) || sum <= 0 || !Number.isInteger(seq) || seq < 0 || seq >= sum) {
+            throw new Error(`invalid event fragment metadata (sum: ${sum}, seq: ${seq})`);
+        }
         const cache = this.cache.get(message_id);
         if (!cache) {
             const buffer = new Array(sum).fill(undefined);
@@ -101990,6 +102004,12 @@ class DataCache {
             });
         }
         else {
+            // A later fragment that disagrees with the first one about `sum` cannot
+            // be placed reliably: its `seq` was only validated against its own sum,
+            // so it could still land outside the allocated buffer and leave a hole.
+            if (sum !== cache.buffer.length) {
+                throw new Error(`invalid event fragment metadata (sum: ${sum} differs from first fragment's ${cache.buffer.length}, seq: ${seq})`);
+            }
             cache.buffer[seq] = data;
         }
         const mergedCache = this.cache.get(message_id);
@@ -102087,12 +102107,26 @@ var HttpStatusCode;
     HttpStatusCode[HttpStatusCode["internal_server_error"] = 500] = "internal_server_error";
 })(HttpStatusCode || (HttpStatusCode = {}));
 
+// Render a thrown value for an error log: prefer the Error message, fall back
+// to String(err) for non-Error throws and Errors with an empty message.
+const describeError = (err) => {
+    const message = err === null || err === void 0 ? void 0 : err.message;
+    return message ? message : String(err);
+};
 class WSClient {
     constructor(params) {
         var _a;
         this.wsConfig = new WSConfig();
         this.reconnectGeneration = 0;
         this.isConnecting = false;
+        /**
+         * Set by {@link close}, cleared by {@link start}. Distinct from
+         * `reconnectGeneration`, which only invalidates *older* loops: a fresh
+         * `reConnect()` bumps the generation itself, so a closed client could
+         * resurrect its own retry loop. This flag says "this client is done"
+         * until someone starts it again.
+         */
+        this.closed = false;
         this.reconnectInfo = {
             lastConnectTime: 0,
             nextConnectTime: 0,
@@ -102174,6 +102208,57 @@ class WSClient {
             this.livenessTimer = undefined;
         }
     }
+    /**
+     * Detach a socket we are about to throw away: drop every listener, but
+     * leave one 'error' sink behind.
+     *
+     * `ws` reports the abort of a non-OPEN socket asynchronously — both
+     * `terminate()` and `close()` route through `abortHandshake()`, which
+     * emits 'error' on a later tick — and a non-force `close()` on an OPEN
+     * socket keeps the connection alive until the peer answers (up to `ws`'s
+     * 30s closeTimeout), during which a TCP reset still surfaces as 'error'.
+     * An EventEmitter with no 'error' listener throws instead of emitting, and
+     * that throw lands outside every try/catch, killing the host process.
+     * See https://github.com/larksuite/node-sdk/issues/197
+     *
+     * NOTE: not for the liveness watchdog — that one terminates *on purpose*
+     * and needs its listeners intact so 'close' drives the reconnect.
+     */
+    detachSocket(socket) {
+        socket.removeAllListeners();
+        // `on`, not `once`: the sink must outlive however many errors `ws`
+        // decides to emit, without depending on its internal de-dup latch.
+        socket.on('error', (err) => {
+            // Message only — the error may carry request details, and connectUrl
+            // is issued by pullConnectConfig and can embed a short-lived ticket.
+            this.logger.debug('[ws]', 'ignored error from discarded socket', err === null || err === void 0 ? void 0 : err.message);
+        });
+    }
+    /**
+     * Throw away whatever the current attempt established — socket *and* the
+     * timers its 'open' handler armed. A handshake that completes after
+     * `close()` runs `pingLoop()`, and that timer is not unref'd: leaving it
+     * behind keeps the event loop alive forever on a client the caller closed.
+     *
+     * Only safe when {@link closed} is set: otherwise a newer session may
+     * already own `wsConfig`'s instance.
+     */
+    discardConnection() {
+        if (this.pingInterval) {
+            clearTimeout(this.pingInterval);
+            this.pingInterval = undefined;
+        }
+        this.clearLiveness();
+        const socket = this.wsConfig.getWSInstance();
+        if (!socket)
+            return;
+        this.detachSocket(socket);
+        try {
+            socket.terminate();
+        }
+        catch ( /* best effort */_a) { /* best effort */ }
+        this.wsConfig.setWSInstance(null);
+    }
     /**
      * Invoke a user-supplied callback safely: no-op if undefined, swallow any
      * exception to avoid breaking the WS state machine.
@@ -102291,7 +102376,7 @@ class WSClient {
             if (this.handshakeTimeoutMs && this.handshakeTimeoutMs > 0) {
                 timer = setTimeout(() => {
                     this.logger.error('[ws]', `handshake timeout after ${this.handshakeTimeoutMs}ms`);
-                    wsInstance.removeAllListeners();
+                    this.detachSocket(wsInstance);
                     try {
                         wsInstance.terminate();
                     }
@@ -102349,6 +102434,19 @@ class WSClient {
                 finally {
                     this.isConnecting = false;
                 }
+                if (this.closed) {
+                    // close() landed while the handshake was still in flight. Drop
+                    // whatever this attempt established — nobody holds a reference to it
+                    // any more — and bail out, so the reConnect() below cannot resurrect
+                    // a client the caller already closed.
+                    this.discardConnection();
+                    return;
+                }
+                if (currentGeneration !== this.reconnectGeneration) {
+                    // Superseded by a newer session, which now owns wsConfig's instance.
+                    // Leave the socket alone and just stop.
+                    return;
+                }
                 if (result.ok) {
                     this.hasEverConnected = true;
                     this.safeInvoke('onReady', this.onReady);
@@ -102396,6 +102494,10 @@ class WSClient {
                         count++;
                         this.currentReconnectAttempts = count;
                         const result = yield tryConnect();
+                        if (this.closed) {
+                            this.discardConnection();
+                            return;
+                        }
                         // Re-check after async operation in case a new session started
                         if (currentGeneration !== this.reconnectGeneration) {
                             return;
@@ -102467,13 +102569,21 @@ class WSClient {
             // Any inbound frame proves the connection is alive — cancel the pong
             // watchdog (but don't re-arm; it'll be armed again on the next ping).
             this.clearLiveness();
-            const data = decode(buffer);
-            const { method } = data;
-            if (method === FrameType.control) {
-                yield this.handleControlData(data);
+            try {
+                const data = decode(buffer);
+                const { method } = data;
+                if (method === FrameType.control) {
+                    yield this.handleControlData(data);
+                }
+                if (method === FrameType.data) {
+                    yield this.handleEventData(data);
+                }
             }
-            if (method === FrameType.data) {
-                yield this.handleEventData(data);
+            catch (err) {
+                // A frame that fails to decode/parse must never be dropped silently or
+                // become an unhandled rejection that can crash the process: log it so
+                // operators can reconcile the loss. See https://github.com/larksuite/node-sdk/issues/201
+                this.logger.error('[ws]', `failed to handle inbound frame: ${describeError(err)}`);
             }
         }));
         wsInstance === null || wsInstance === void 0 ? void 0 : wsInstance.on('error', (e) => {
@@ -102495,8 +102605,18 @@ class WSClient {
             }
             if (type === MessageType.pong && payload) {
                 this.logger.trace('[ws]', 'receive pong');
-                const dataString = new TextDecoder("utf-8").decode(payload);
-                const { PingInterval, ReconnectCount, ReconnectInterval, ReconnectNonce } = JSON.parse(dataString);
+                let pong;
+                try {
+                    const dataString = new TextDecoder("utf-8").decode(payload);
+                    pong = JSON.parse(dataString);
+                }
+                catch (err) {
+                    // A malformed pong must not drop the frame silently or crash the
+                    // process. See https://github.com/larksuite/node-sdk/issues/201
+                    this.logger.error('[ws]', `invalid pong payload: ${describeError(err)}`);
+                    return;
+                }
+                const { PingInterval, ReconnectCount, ReconnectInterval, ReconnectNonce } = pong;
                 this.wsConfig.updateWs({
                     pingInterval: PingInterval * 1000,
                     reconnectCount: ReconnectCount,
@@ -102519,13 +102639,23 @@ class WSClient {
             if (type !== MessageType.event) {
                 return;
             }
-            const mergedData = this.dataCache.mergeData({
-                message_id,
-                sum: Number(sum),
-                seq: Number(seq),
-                trace_id,
-                data: payload
-            });
+            let mergedData;
+            try {
+                mergedData = this.dataCache.mergeData({
+                    message_id,
+                    sum: Number(sum),
+                    seq: Number(seq),
+                    trace_id,
+                    data: payload
+                });
+            }
+            catch (err) {
+                // Malformed fragment metadata must not be dropped silently: log the
+                // metadata so operators can reconcile.
+                // See https://github.com/larksuite/node-sdk/issues/201
+                this.logger.error('[ws]', `failed to merge event fragments, message_id: ${message_id}; trace_id: ${trace_id}; error: ${describeError(err)}`);
+                return;
+            }
             if (!mergedData) {
                 return;
             }
@@ -102595,6 +102725,7 @@ class WSClient {
      */
     close(params = {}) {
         const { force = false } = params;
+        this.closed = true;
         // Invalidate any in-flight reconnect loops
         this.reconnectGeneration++;
         if (this.pingInterval) {
@@ -102611,7 +102742,7 @@ class WSClient {
         this.currentReconnectAttempts = 0;
         const wsInstance = this.wsConfig.getWSInstance();
         if (wsInstance) {
-            wsInstance.removeAllListeners();
+            this.detachSocket(wsInstance);
             if (force) {
                 wsInstance.terminate();
             }
@@ -102637,6 +102768,7 @@ class WSClient {
             // Clear any terminal-error state left over from a previous session so
             // getConnectionStatus() reflects the fresh start.
             this.terminalError = false;
+            this.closed = false;
             this.currentReconnectAttempts = 0;
             // Re-arm the cache sweep in case the client was previously close()d
             // (which destroys the timer); idempotent when already running.
@@ -103097,6 +103229,7 @@ function startPolling(ctx) {
         let domainSwitched = false;
         let pollTimer = null;
         let expireTimer = null;
+        let settled = false;
         const cleanup = () => {
             var _a;
             if (pollTimer !== null) {
@@ -103109,25 +103242,60 @@ function startPolling(ctx) {
             }
             (_a = ctx.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener('abort', onAbort);
         };
-        const onAbort = () => {
+        // Every terminal transition goes through succeed() / fail(): they flip
+        // `settled`, drop the timers and the abort listener, and ignore any later
+        // call. Keeping that bookkeeping in one place is what stops a cancelled
+        // run from resuming — see issue #211.
+        const succeed = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            cleanup();
+            resolve(result);
+        };
+        const fail = (err) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
             cleanup();
-            reject(createError('abort', 'Registration was aborted'));
+            reject(err);
+        };
+        // Scheduling is guarded too: a status callback may abort the run
+        // synchronously, and a timer armed after cleanup() would never be cleared.
+        const scheduleNextPoll = () => {
+            if (settled) {
+                return;
+            }
+            pollTimer = setTimeout(poll, interval);
+        };
+        const onAbort = () => {
+            fail(createError('abort', 'Registration was aborted'));
         };
         if ((_a = ctx.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
-            return reject(createError('abort', 'Registration was aborted'));
+            return fail(createError('abort', 'Registration was aborted'));
         }
         (_b = ctx.signal) === null || _b === void 0 ? void 0 : _b.addEventListener('abort', onAbort, { once: true });
         expireTimer = setTimeout(() => {
-            cleanup();
-            reject(createError('expired_token', 'Polling timed out'));
+            fail(createError('expired_token', 'Polling timed out'));
         }, ctx.expireIn);
         const poll = () => __awaiter(this, void 0, void 0, function* () {
             var _c, _d, _e, _f, _g, _h;
+            if (settled) {
+                return;
+            }
             try {
                 const pollRes = yield requestRegistration(baseUrl, {
                     action: 'poll',
                     device_code: ctx.deviceCode,
                 });
+                // The run may have been aborted or have expired while this request
+                // was in flight. Drop the response: no status callback, no next
+                // poll (issue #211).
+                if (settled) {
+                    return;
+                }
                 // Lark domain switch (once only)
                 if (((_c = pollRes.user_info) === null || _c === void 0 ? void 0 : _c.tenant_brand) === 'lark' && !domainSwitched) {
                     baseUrl = ctx.larkBaseUrl;
@@ -103138,8 +103306,7 @@ function startPolling(ctx) {
                 }
                 // Success
                 if (pollRes.client_id && pollRes.client_secret) {
-                    cleanup();
-                    resolve({
+                    succeed({
                         client_id: pollRes.client_id,
                         client_secret: pollRes.client_secret,
                         user_info: pollRes.user_info,
@@ -103157,22 +103324,19 @@ function startPolling(ctx) {
                         break;
                     case 'access_denied':
                     case 'expired_token':
-                        cleanup();
-                        reject(createError(pollRes.error, (_g = pollRes.error_description) !== null && _g !== void 0 ? _g : 'Unknown error'));
+                        fail(createError(pollRes.error, (_g = pollRes.error_description) !== null && _g !== void 0 ? _g : 'Unknown error'));
                         return;
                     default:
                         if (pollRes.error) {
-                            cleanup();
-                            reject(createError(pollRes.error, (_h = pollRes.error_description) !== null && _h !== void 0 ? _h : 'Unknown error'));
+                            fail(createError(pollRes.error, (_h = pollRes.error_description) !== null && _h !== void 0 ? _h : 'Unknown error'));
                             return;
                         }
                         break;
                 }
-                pollTimer = setTimeout(poll, interval);
+                scheduleNextPoll();
             }
             catch (e) {
-                cleanup();
-                reject(e);
+                fail(e);
             }
         });
         poll();

package/node_modules/@larksuiteoapi/node-sdk/package.json

@@ -1 +1 @@
-{"name":"@larksuiteoapi/node-sdk","version":"1.73.0","description":"larksuite open sdk for nodejs","keywords":["feishu","larksuite","sdk","nodejs"],"types":"./types","main":"./lib/index.js","module":"./es/index.js","files":["lib","es","types","README.zh.md","README.md","LICENSE"],"scripts":{"build":"rm -r lib es types & rollup -c","test":"jest","test:watch":"jest --watch --testPathPattern=utils/__tests__"},"author":"mazhe.nerd","license":"MIT","repository":{"type":"git","url":"https://github.com/larksuite/node-sdk.git"},"homepage":"https://github.com/larksuite/node-sdk","bugs":{"url":"https://github.com/larksuite/node-sdk/issues"},"dependencies":{"axios":"^1.16.0","lodash.identity":"^3.0.0","lodash.merge":"^4.6.2","lodash.pickby":"^4.6.0","protobufjs":"^7.2.6","qs":"^6.14.2","ws":"^8.19.0"},"devDependencies":{"@koa/router":"^12.0.0","@rollup/plugin-alias":"^3.1.9","@rollup/plugin-typescript":"^8.3.2","@types/jest":"^28.1.3","@types/lodash.merge":"^4.6.7","@types/lodash.pick":"^4.4.7","@types/qs":"^6.9.16","@types/ws":"^8.5.10","@typescript-eslint/parser":"^5.27.1","body-parser":"^1.20.1","eslint":"^8.17.0","eslint-config-airbnb-base":"^15.0.0","eslint-config-prettier":"^8.5.0","eslint-plugin-import":"^2.26.0","express":"^4.18.2","jest":"^28.1.1","koa":"^2.13.4","koa-body":"^5.0.0","prettier":"2.6.2","rollup":"^2.75.5","rollup-plugin-dts":"^4.2.2","rollup-plugin-license":"^2.8.1","ts-jest":"^28.0.5","ts-node":"^10.8.1","tsconfig-paths":"^4.0.0","tslib":"^2.4.0","typescript":"^4.7.3"},"publishConfig":{"access":"public"}}
+{"name":"@larksuiteoapi/node-sdk","version":"1.73.3","description":"larksuite open sdk for nodejs","keywords":["feishu","larksuite","sdk","nodejs"],"types":"./types","main":"./lib/index.js","module":"./es/index.js","files":["lib","es","types","README.zh.md","README.md","LICENSE"],"scripts":{"build":"rm -r lib es types & rollup -c","test":"jest","test:watch":"jest --watch --testPathPattern=utils/__tests__"},"author":"mazhe.nerd","license":"MIT","repository":{"type":"git","url":"https://github.com/larksuite/node-sdk.git"},"homepage":"https://github.com/larksuite/node-sdk","bugs":{"url":"https://github.com/larksuite/node-sdk/issues"},"dependencies":{"axios":"^1.16.0","lodash.identity":"^3.0.0","lodash.merge":"^4.6.2","lodash.pickby":"^4.6.0","protobufjs":"^7.2.6","qs":"^6.14.2","ws":"^8.19.0"},"devDependencies":{"@koa/router":"^12.0.0","@rollup/plugin-alias":"^3.1.9","@rollup/plugin-typescript":"^8.3.2","@types/jest":"^28.1.3","@types/lodash.merge":"^4.6.7","@types/lodash.pick":"^4.4.7","@types/qs":"^6.9.16","@types/ws":"^8.5.10","@typescript-eslint/parser":"^5.27.1","body-parser":"^1.20.1","eslint":"^8.17.0","eslint-config-airbnb-base":"^15.0.0","eslint-config-prettier":"^8.5.0","eslint-plugin-import":"^2.26.0","express":"^4.18.2","jest":"^28.1.1","koa":"^2.13.4","koa-body":"^5.0.0","prettier":"2.6.2","rollup":"^2.75.5","rollup-plugin-dts":"^4.2.2","rollup-plugin-license":"^2.8.1","ts-jest":"^28.0.5","ts-node":"^10.8.1","tsconfig-paths":"^4.0.0","tslib":"^2.4.0","typescript":"^4.7.3"},"publishConfig":{"access":"public"}}

package/node_modules/@maka/core/dist/agent-graph-schedule.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { isExecutorId } from './executor-id.js';
 export const AGENT_GRAPH_SCHEDULE_UPDATE_SCHEMA_VERSION = 1;
 export const AGENT_GRAPH_SCHEDULE_MAX_ADD_WORK = 32;
 export const AGENT_GRAPH_SCHEDULE_MAX_STOP = 20;
@@ -192,14 +193,24 @@ function isSelectedResultInput(value) {
 function isWorkTarget(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return false;
-    if (isExactRecord(value, ['kind', 'agentId']) &&
+    if (isExactRecord(value, [
+        'kind',
+        'agentId',
+        ...(hasOwn(value, 'executorId') ? ['executorId'] : []),
+    ]) &&
         value.kind === 'agent' &&
-        isOpaqueIdentity(value.agentId)) {
+        isOpaqueIdentity(value.agentId) &&
+        (value.executorId === undefined || isExecutorId(value.executorId))) {
         return true;
     }
-    if (isExactRecord(value, ['kind', 'presetId']) &&
+    if (isExactRecord(value, [
+        'kind',
+        'presetId',
+        ...(hasOwn(value, 'executorId') ? ['executorId'] : []),
+    ]) &&
         value.kind === 'preset' &&
-        isOpaqueIdentity(value.presetId)) {
+        isOpaqueIdentity(value.presetId) &&
+        (value.executorId === undefined || isExecutorId(value.executorId))) {
         return true;
     }
     return (isExactRecord(value, ['kind', 'operatorId']) &&