@gguf/claw 2026.2.1 → 2026.2.3

package/dist/gateway/protocol/schema/protocol-schemas.js

@@ -1,10 +1,10 @@
 import { AgentEventSchema, AgentIdentityParamsSchema, AgentIdentityResultSchema, AgentParamsSchema, AgentWaitParamsSchema, PollParamsSchema, SendParamsSchema, WakeParamsSchema, } from "./agent.js";
-import { AgentSummarySchema, AgentsListParamsSchema, AgentsListResultSchema, ModelChoiceSchema, ModelsListParamsSchema, ModelsListResultSchema, SkillsBinsParamsSchema, SkillsBinsResultSchema, SkillsInstallParamsSchema, SkillsStatusParamsSchema, SkillsUpdateParamsSchema, } from "./agents-models-skills.js";
+import { AgentSummarySchema, AgentsFileEntrySchema, AgentsFilesGetParamsSchema, AgentsFilesGetResultSchema, AgentsFilesListParamsSchema, AgentsFilesListResultSchema, AgentsFilesSetParamsSchema, AgentsFilesSetResultSchema, AgentsListParamsSchema, AgentsListResultSchema, ModelChoiceSchema, ModelsListParamsSchema, ModelsListResultSchema, SkillsBinsParamsSchema, SkillsBinsResultSchema, SkillsInstallParamsSchema, SkillsStatusParamsSchema, SkillsUpdateParamsSchema, } from "./agents-models-skills.js";
 import { ChannelsLogoutParamsSchema, ChannelsStatusParamsSchema, ChannelsStatusResultSchema, TalkModeParamsSchema, WebLoginStartParamsSchema, WebLoginWaitParamsSchema, } from "./channels.js";
 import { ConfigApplyParamsSchema, ConfigGetParamsSchema, ConfigPatchParamsSchema, ConfigSchemaParamsSchema, ConfigSchemaResponseSchema, ConfigSetParamsSchema, UpdateRunParamsSchema, } from "./config.js";
 import { CronAddParamsSchema, CronJobSchema, CronListParamsSchema, CronRemoveParamsSchema, CronRunLogEntrySchema, CronRunParamsSchema, CronRunsParamsSchema, CronStatusParamsSchema, CronUpdateParamsSchema, } from "./cron.js";
-import { ExecApprovalsGetParamsSchema, ExecApprovalsNodeGetParamsSchema, ExecApprovalsNodeSetParamsSchema, ExecApprovalsSetParamsSchema, ExecApprovalsSnapshotSchema, ExecApprovalRequestParamsSchema, ExecApprovalResolveParamsSchema, } from "./exec-approvals.js";
 import { DevicePairApproveParamsSchema, DevicePairListParamsSchema, DevicePairRejectParamsSchema, DevicePairRequestedEventSchema, DevicePairResolvedEventSchema, DeviceTokenRevokeParamsSchema, DeviceTokenRotateParamsSchema, } from "./devices.js";
+import { ExecApprovalsGetParamsSchema, ExecApprovalsNodeGetParamsSchema, ExecApprovalsNodeSetParamsSchema, ExecApprovalsSetParamsSchema, ExecApprovalsSnapshotSchema, ExecApprovalRequestParamsSchema, ExecApprovalResolveParamsSchema, } from "./exec-approvals.js";
 import { ConnectParamsSchema, ErrorShapeSchema, EventFrameSchema, GatewayFrameSchema, HelloOkSchema, RequestFrameSchema, ResponseFrameSchema, ShutdownEventSchema, TickEventSchema, } from "./frames.js";
 import { ChatAbortParamsSchema, ChatEventSchema, ChatHistoryParamsSchema, ChatInjectParamsSchema, ChatSendParamsSchema, LogsTailParamsSchema, LogsTailResultSchema, } from "./logs-chat.js";
 import { NodeDescribeParamsSchema, NodeEventParamsSchema, NodeInvokeParamsSchema, NodeInvokeResultParamsSchema, NodeInvokeRequestEventSchema, NodeListParamsSchema, NodePairApproveParamsSchema, NodePairListParamsSchema, NodePairRejectParamsSchema, NodePairRequestParamsSchema, NodePairVerifyParamsSchema, NodeRenameParamsSchema, } from "./nodes.js";
@@ -70,6 +70,13 @@ export const ProtocolSchemas = {
     WebLoginStartParams: WebLoginStartParamsSchema,
     WebLoginWaitParams: WebLoginWaitParamsSchema,
     AgentSummary: AgentSummarySchema,
+    AgentsFileEntry: AgentsFileEntrySchema,
+    AgentsFilesListParams: AgentsFilesListParamsSchema,
+    AgentsFilesListResult: AgentsFilesListResultSchema,
+    AgentsFilesGetParams: AgentsFilesGetParamsSchema,
+    AgentsFilesGetResult: AgentsFilesGetResultSchema,
+    AgentsFilesSetParams: AgentsFilesSetParamsSchema,
+    AgentsFilesSetResult: AgentsFilesSetResultSchema,
     AgentsListParams: AgentsListParamsSchema,
     AgentsListResult: AgentsListResultSchema,
     ModelChoice: ModelChoiceSchema,

package/dist/gateway/protocol/schema/types.d.ts

@@ -1,11 +1,11 @@
 import type { Static } from "@sinclair/typebox";
 import type { AgentEventSchema, AgentIdentityParamsSchema, AgentIdentityResultSchema, AgentWaitParamsSchema, PollParamsSchema, WakeParamsSchema } from "./agent.js";
-import type { AgentSummarySchema, AgentsListParamsSchema, AgentsListResultSchema, ModelChoiceSchema, ModelsListParamsSchema, ModelsListResultSchema, SkillsBinsParamsSchema, SkillsBinsResultSchema, SkillsInstallParamsSchema, SkillsStatusParamsSchema, SkillsUpdateParamsSchema } from "./agents-models-skills.js";
+import type { AgentSummarySchema, AgentsFileEntrySchema, AgentsFilesGetParamsSchema, AgentsFilesGetResultSchema, AgentsFilesListParamsSchema, AgentsFilesListResultSchema, AgentsFilesSetParamsSchema, AgentsFilesSetResultSchema, AgentsListParamsSchema, AgentsListResultSchema, ModelChoiceSchema, ModelsListParamsSchema, ModelsListResultSchema, SkillsBinsParamsSchema, SkillsBinsResultSchema, SkillsInstallParamsSchema, SkillsStatusParamsSchema, SkillsUpdateParamsSchema } from "./agents-models-skills.js";
 import type { ChannelsLogoutParamsSchema, ChannelsStatusParamsSchema, ChannelsStatusResultSchema, TalkModeParamsSchema, WebLoginStartParamsSchema, WebLoginWaitParamsSchema } from "./channels.js";
 import type { ConfigApplyParamsSchema, ConfigGetParamsSchema, ConfigPatchParamsSchema, ConfigSchemaParamsSchema, ConfigSchemaResponseSchema, ConfigSetParamsSchema, UpdateRunParamsSchema } from "./config.js";
 import type { CronAddParamsSchema, CronJobSchema, CronListParamsSchema, CronRemoveParamsSchema, CronRunLogEntrySchema, CronRunParamsSchema, CronRunsParamsSchema, CronStatusParamsSchema, CronUpdateParamsSchema } from "./cron.js";
-import type { ExecApprovalsGetParamsSchema, ExecApprovalsNodeGetParamsSchema, ExecApprovalsNodeSetParamsSchema, ExecApprovalsSetParamsSchema, ExecApprovalsSnapshotSchema, ExecApprovalRequestParamsSchema, ExecApprovalResolveParamsSchema } from "./exec-approvals.js";
 import type { DevicePairApproveParamsSchema, DevicePairListParamsSchema, DevicePairRejectParamsSchema, DeviceTokenRevokeParamsSchema, DeviceTokenRotateParamsSchema } from "./devices.js";
+import type { ExecApprovalsGetParamsSchema, ExecApprovalsNodeGetParamsSchema, ExecApprovalsNodeSetParamsSchema, ExecApprovalsSetParamsSchema, ExecApprovalsSnapshotSchema, ExecApprovalRequestParamsSchema, ExecApprovalResolveParamsSchema } from "./exec-approvals.js";
 import type { ConnectParamsSchema, ErrorShapeSchema, EventFrameSchema, GatewayFrameSchema, HelloOkSchema, RequestFrameSchema, ResponseFrameSchema, ShutdownEventSchema, TickEventSchema } from "./frames.js";
 import type { ChatAbortParamsSchema, ChatEventSchema, ChatInjectParamsSchema, LogsTailParamsSchema, LogsTailResultSchema } from "./logs-chat.js";
 import type { NodeDescribeParamsSchema, NodeEventParamsSchema, NodeInvokeParamsSchema, NodeInvokeResultParamsSchema, NodeListParamsSchema, NodePairApproveParamsSchema, NodePairListParamsSchema, NodePairRejectParamsSchema, NodePairRequestParamsSchema, NodePairVerifyParamsSchema, NodeRenameParamsSchema } from "./nodes.js";
@@ -67,6 +67,13 @@ export type ChannelsLogoutParams = Static<typeof ChannelsLogoutParamsSchema>;
 export type WebLoginStartParams = Static<typeof WebLoginStartParamsSchema>;
 export type WebLoginWaitParams = Static<typeof WebLoginWaitParamsSchema>;
 export type AgentSummary = Static<typeof AgentSummarySchema>;
+export type AgentsFileEntry = Static<typeof AgentsFileEntrySchema>;
+export type AgentsFilesListParams = Static<typeof AgentsFilesListParamsSchema>;
+export type AgentsFilesListResult = Static<typeof AgentsFilesListResultSchema>;
+export type AgentsFilesGetParams = Static<typeof AgentsFilesGetParamsSchema>;
+export type AgentsFilesGetResult = Static<typeof AgentsFilesGetResultSchema>;
+export type AgentsFilesSetParams = Static<typeof AgentsFilesSetParamsSchema>;
+export type AgentsFilesSetResult = Static<typeof AgentsFilesSetResultSchema>;
 export type AgentsListParams = Static<typeof AgentsListParamsSchema>;
 export type AgentsListResult = Static<typeof AgentsListResultSchema>;
 export type ModelChoice = Static<typeof ModelChoiceSchema>;

package/dist/gateway/server/health-state.d.ts

@@ -1,5 +1,5 @@
-import { type HealthSummary } from "../../commands/health.js";
 import type { Snapshot } from "../protocol/index.js";
+import { type HealthSummary } from "../../commands/health.js";
 export declare function buildGatewaySnapshot(): Snapshot;
 export declare function getHealthCache(): HealthSummary | null;
 export declare function getHealthVersion(): number;

package/dist/gateway/server/health-state.js

@@ -2,8 +2,8 @@ import { resolveDefaultAgentId } from "../../agents/agent-scope.js";
 import { getHealthSnapshot } from "../../commands/health.js";
 import { CONFIG_PATH, STATE_DIR, loadConfig } from "../../config/config.js";
 import { resolveMainSessionKey } from "../../config/sessions.js";
-import { normalizeMainKey } from "../../routing/session-key.js";
 import { listSystemPresence } from "../../infra/system-presence.js";
+import { normalizeMainKey } from "../../routing/session-key.js";
 let presenceVersion = 1;
 let healthVersion = 1;
 let healthCache = null;

package/dist/gateway/server/ws-connection/message-handler.js

@@ -1,19 +1,19 @@
 import os from "node:os";
+import { loadConfig } from "../../../config/config.js";
 import { deriveDeviceIdFromPublicKey, normalizeDevicePublicKeyBase64Url, verifyDeviceSignature, } from "../../../infra/device-identity.js";
 import { approveDevicePairing, ensureDeviceToken, getPairedDevice, requestDevicePairing, updatePairedDeviceMetadata, verifyDeviceToken, } from "../../../infra/device-pairing.js";
 import { updatePairedNodeMetadata } from "../../../infra/node-pairing.js";
 import { recordRemoteNodeInfo, refreshRemoteNodeBins } from "../../../infra/skills-remote.js";
-import { loadVoiceWakeConfig } from "../../../infra/voicewake.js";
 import { upsertPresence } from "../../../infra/system-presence.js";
+import { loadVoiceWakeConfig } from "../../../infra/voicewake.js";
 import { rawDataToString } from "../../../infra/ws.js";
 import { isGatewayCliClient, isWebchatClient } from "../../../utils/message-channel.js";
 import { authorizeGatewayConnect, isLocalDirectRequest } from "../../auth.js";
-import { loadConfig } from "../../../config/config.js";
 import { buildDeviceAuthPayload } from "../../device-auth.js";
 import { isLoopbackAddress, isTrustedProxyAddress, resolveGatewayClientIp } from "../../net.js";
 import { resolveNodeCommandAllowlist } from "../../node-command-policy.js";
-import { ErrorCodes, errorShape, formatValidationErrors, PROTOCOL_VERSION, validateConnectParams, validateRequestFrame, } from "../../protocol/index.js";
 import { GATEWAY_CLIENT_IDS } from "../../protocol/client-info.js";
+import { ErrorCodes, errorShape, formatValidationErrors, PROTOCOL_VERSION, validateConnectParams, validateRequestFrame, } from "../../protocol/index.js";
 import { MAX_BUFFERED_BYTES, MAX_PAYLOAD_BYTES, TICK_INTERVAL_MS } from "../../server-constants.js";
 import { handleGatewayRequest } from "../../server-methods.js";
 import { formatError } from "../../server-utils.js";
@@ -248,8 +248,58 @@ export function attachGatewayWsMessageHandler(params) {
                 const disableControlUiDeviceAuth = isControlUi && configSnapshot.gateway?.controlUi?.dangerouslyDisableDeviceAuth === true;
                 const allowControlUiBypass = allowInsecureControlUi || disableControlUiDeviceAuth;
                 const device = disableControlUiDeviceAuth ? null : deviceRaw;
+                const authResult = await authorizeGatewayConnect({
+                    auth: resolvedAuth,
+                    connectAuth: connectParams.auth,
+                    req: upgradeReq,
+                    trustedProxies,
+                });
+                let authOk = authResult.ok;
+                let authMethod = authResult.method ?? (resolvedAuth.mode === "password" ? "password" : "token");
+                const sharedAuthResult = hasSharedAuth
+                    ? await authorizeGatewayConnect({
+                        auth: { ...resolvedAuth, allowTailscale: false },
+                        connectAuth: connectParams.auth,
+                        req: upgradeReq,
+                        trustedProxies,
+                    })
+                    : null;
+                const sharedAuthOk = sharedAuthResult?.ok === true &&
+                    (sharedAuthResult.method === "token" || sharedAuthResult.method === "password");
+                const rejectUnauthorized = () => {
+                    setHandshakeState("failed");
+                    logWsControl.warn(`unauthorized conn=${connId} remote=${remoteAddr ?? "?"} client=${clientLabel} ${connectParams.client.mode} v${connectParams.client.version} reason=${authResult.reason ?? "unknown"}`);
+                    const authProvided = connectParams.auth?.token
+                        ? "token"
+                        : connectParams.auth?.password
+                            ? "password"
+                            : "none";
+                    const authMessage = formatGatewayAuthFailureMessage({
+                        authMode: resolvedAuth.mode,
+                        authProvided,
+                        reason: authResult.reason,
+                        client: connectParams.client,
+                    });
+                    setCloseCause("unauthorized", {
+                        authMode: resolvedAuth.mode,
+                        authProvided,
+                        authReason: authResult.reason,
+                        allowTailscale: resolvedAuth.allowTailscale,
+                        client: connectParams.client.id,
+                        clientDisplayName: connectParams.client.displayName,
+                        mode: connectParams.client.mode,
+                        version: connectParams.client.version,
+                    });
+                    send({
+                        type: "res",
+                        id: frame.id,
+                        ok: false,
+                        error: errorShape(ErrorCodes.INVALID_REQUEST, authMessage),
+                    });
+                    close(1008, truncateCloseReason(authMessage));
+                };
                 if (!device) {
-                    const canSkipDevice = allowControlUiBypass ? hasSharedAuth : hasTokenAuth;
+                    const canSkipDevice = sharedAuthOk;
                     if (isControlUi && !allowControlUiBypass) {
                         const errorMessage = "control ui requires HTTPS or localhost (secure context)";
                         setHandshakeState("failed");
@@ -268,8 +318,12 @@ export function attachGatewayWsMessageHandler(params) {
                         close(1008, errorMessage);
                         return;
                     }
-                    // Allow token-authenticated connections (e.g., control-ui) to skip device identity
+                    // Allow shared-secret authenticated connections (e.g., control-ui) to skip device identity
                     if (!canSkipDevice) {
+                        if (!authOk && hasSharedAuth) {
+                            rejectUnauthorized();
+                            return;
+                        }
                         setHandshakeState("failed");
                         setCloseCause("device-required", {
                             client: connectParams.client.id,
@@ -435,14 +489,6 @@ export function attachGatewayWsMessageHandler(params) {
                         return;
                     }
                 }
-                const authResult = await authorizeGatewayConnect({
-                    auth: resolvedAuth,
-                    connectAuth: connectParams.auth,
-                    req: upgradeReq,
-                    trustedProxies,
-                });
-                let authOk = authResult.ok;
-                let authMethod = authResult.method ?? (resolvedAuth.mode === "password" ? "password" : "token");
                 if (!authOk && connectParams.auth?.token && device) {
                     const tokenCheck = await verifyDeviceToken({
                         deviceId: device.id,
@@ -456,39 +502,10 @@ export function attachGatewayWsMessageHandler(params) {
                     }
                 }
                 if (!authOk) {
-                    setHandshakeState("failed");
-                    logWsControl.warn(`unauthorized conn=${connId} remote=${remoteAddr ?? "?"} client=${clientLabel} ${connectParams.client.mode} v${connectParams.client.version} reason=${authResult.reason ?? "unknown"}`);
-                    const authProvided = connectParams.auth?.token
-                        ? "token"
-                        : connectParams.auth?.password
-                            ? "password"
-                            : "none";
-                    const authMessage = formatGatewayAuthFailureMessage({
-                        authMode: resolvedAuth.mode,
-                        authProvided,
-                        reason: authResult.reason,
-                        client: connectParams.client,
-                    });
-                    setCloseCause("unauthorized", {
-                        authMode: resolvedAuth.mode,
-                        authProvided,
-                        authReason: authResult.reason,
-                        allowTailscale: resolvedAuth.allowTailscale,
-                        client: connectParams.client.id,
-                        clientDisplayName: connectParams.client.displayName,
-                        mode: connectParams.client.mode,
-                        version: connectParams.client.version,
-                    });
-                    send({
-                        type: "res",
-                        id: frame.id,
-                        ok: false,
-                        error: errorShape(ErrorCodes.INVALID_REQUEST, authMessage),
-                    });
-                    close(1008, truncateCloseReason(authMessage));
+                    rejectUnauthorized();
                     return;
                 }
-                const skipPairing = allowControlUiBypass && hasSharedAuth;
+                const skipPairing = allowControlUiBypass && sharedAuthOk;
                 if (device && devicePublicKey && !skipPairing) {
                     const requirePairing = async (reason, _paired) => {
                         const pairing = await requestDevicePairing({

package/dist/gateway/server-channels.d.ts

@@ -1,8 +1,8 @@
-import { type ChannelId } from "../channels/plugins/index.js";
 import type { ChannelAccountSnapshot } from "../channels/plugins/types.js";
 import type { OpenClawConfig } from "../config/config.js";
 import type { createSubsystemLogger } from "../logging/subsystem.js";
 import type { RuntimeEnv } from "../runtime.js";
+import { type ChannelId } from "../channels/plugins/index.js";
 export type ChannelRuntimeSnapshot = {
     channels: Partial<Record<ChannelId, ChannelAccountSnapshot>>;
     channelAccounts: Partial<Record<ChannelId, Record<string, ChannelAccountSnapshot>>>;

package/dist/gateway/server-close.d.ts

@@ -1,9 +1,9 @@
 import type { Server as HttpServer } from "node:http";
 import type { WebSocketServer } from "ws";
 import type { CanvasHostHandler, CanvasHostServer } from "../canvas-host/server.js";
-import { type ChannelId } from "../channels/plugins/index.js";
 import type { HeartbeatRunner } from "../infra/heartbeat-runner.js";
 import type { PluginServicesHandle } from "../plugins/services.js";
+import { type ChannelId } from "../channels/plugins/index.js";
 export declare function createGatewayCloseHandler(params: {
     bonjourStop: (() => Promise<void>) | null;
     tailscaleCleanup: (() => Promise<void>) | null;

package/dist/gateway/server-http.d.ts

@@ -1,6 +1,6 @@
-import { type Server as HttpServer, type IncomingMessage, type ServerResponse } from "node:http";
 import type { TlsOptions } from "node:tls";
 import type { WebSocketServer } from "ws";
+import { type Server as HttpServer, type IncomingMessage, type ServerResponse } from "node:http";
 import type { CanvasHostHandler } from "../canvas-host/server.js";
 import type { createSubsystemLogger } from "../logging/subsystem.js";
 import { type HookMessageChannel, type HooksConfigResolved } from "./hooks.js";

package/dist/gateway/server-http.js

@@ -1,12 +1,12 @@
 import { createServer as createHttpServer, } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
+import { resolveAgentAvatar } from "../agents/identity-avatar.js";
 import { handleA2uiHttpRequest } from "../canvas-host/a2ui.js";
 import { loadConfig } from "../config/config.js";
 import { handleSlackHttpRequest } from "../slack/http/index.js";
-import { resolveAgentAvatar } from "../agents/identity-avatar.js";
 import { handleControlUiAvatarRequest, handleControlUiHttpRequest } from "./control-ui.js";
-import { extractHookToken, getHookChannelError, normalizeAgentPayload, normalizeHookHeaders, normalizeWakePayload, readJsonBody, resolveHookChannel, resolveHookDeliver, } from "./hooks.js";
 import { applyHookMappings } from "./hooks-mapping.js";
+import { extractHookToken, getHookChannelError, normalizeAgentPayload, normalizeHookHeaders, normalizeWakePayload, readJsonBody, resolveHookChannel, resolveHookDeliver, } from "./hooks.js";
 import { handleOpenAiHttpRequest } from "./openai-http.js";
 import { handleOpenResponsesHttpRequest } from "./openresponses-http.js";
 import { handleToolsInvokeHttpRequest } from "./tools-invoke-http.js";

package/dist/gateway/server-maintenance.d.ts

@@ -1,7 +1,7 @@
 import type { HealthSummary } from "../commands/health.js";
-import { type ChatAbortControllerEntry } from "./chat-abort.js";
 import type { ChatRunEntry } from "./server-chat.js";
 import type { DedupeEntry } from "./server-shared.js";
+import { type ChatAbortControllerEntry } from "./chat-abort.js";
 export declare function startGatewayMaintenanceTimers(params: {
     broadcast: (event: string, payload: unknown, opts?: {
         dropIfSlow?: boolean;

package/dist/gateway/server-maintenance.js

@@ -1,7 +1,7 @@
 import { abortChatRunById } from "./chat-abort.js";
-import { setBroadcastHealthUpdate } from "./server/health-state.js";
 import { DEDUPE_MAX, DEDUPE_TTL_MS, HEALTH_REFRESH_INTERVAL_MS, TICK_INTERVAL_MS, } from "./server-constants.js";
 import { formatError } from "./server-utils.js";
+import { setBroadcastHealthUpdate } from "./server/health-state.js";
 export function startGatewayMaintenanceTimers(params) {
     setBroadcastHealthUpdate((snap) => {
         params.broadcast("health", snap, {

package/dist/gateway/server-methods/agent.js

@@ -1,23 +1,23 @@
 import { randomUUID } from "node:crypto";
-import { agentCommand } from "../../commands/agent.js";
 import { listAgentIds } from "../../agents/agent-scope.js";
+import { agentCommand } from "../../commands/agent.js";
 import { loadConfig } from "../../config/config.js";
-import { injectTimestamp, timestampOptsFromConfig } from "./agent-timestamp.js";
 import { resolveAgentIdFromSessionKey, resolveExplicitAgentSessionKey, resolveAgentMainSessionKey, updateSessionStore, } from "../../config/sessions.js";
 import { registerAgentRunContext } from "../../infra/agent-events.js";
 import { resolveAgentDeliveryPlan, resolveAgentOutboundTarget, } from "../../infra/outbound/agent-delivery.js";
+import { normalizeAgentId } from "../../routing/session-key.js";
 import { defaultRuntime } from "../../runtime.js";
 import { resolveSendPolicy } from "../../sessions/send-policy.js";
 import { normalizeSessionDeliveryFields } from "../../utils/delivery-context.js";
 import { INTERNAL_MESSAGE_CHANNEL, isDeliverableMessageChannel, isGatewayMessageChannel, normalizeMessageChannel, } from "../../utils/message-channel.js";
-import { normalizeAgentId } from "../../routing/session-key.js";
+import { resolveAssistantIdentity } from "../assistant-identity.js";
 import { parseMessageWithAttachments } from "../chat-attachments.js";
+import { resolveAssistantAvatarUrl } from "../control-ui-shared.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateAgentIdentityParams, validateAgentParams, validateAgentWaitParams, } from "../protocol/index.js";
 import { loadSessionEntry } from "../session-utils.js";
 import { formatForLog } from "../ws-log.js";
-import { resolveAssistantIdentity } from "../assistant-identity.js";
-import { resolveAssistantAvatarUrl } from "../control-ui-shared.js";
 import { waitForAgentJob } from "./agent-job.js";
+import { injectTimestamp, timestampOptsFromConfig } from "./agent-timestamp.js";
 export const agentHandlers = {
     agent: async ({ params, respond, context }) => {
         const p = params;

package/dist/gateway/server-methods/agents.js

@@ -1,6 +1,92 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { listAgentIds, resolveAgentWorkspaceDir } from "../../agents/agent-scope.js";
+import { DEFAULT_AGENTS_FILENAME, DEFAULT_BOOTSTRAP_FILENAME, DEFAULT_HEARTBEAT_FILENAME, DEFAULT_IDENTITY_FILENAME, DEFAULT_MEMORY_ALT_FILENAME, DEFAULT_MEMORY_FILENAME, DEFAULT_SOUL_FILENAME, DEFAULT_TOOLS_FILENAME, DEFAULT_USER_FILENAME, } from "../../agents/workspace.js";
 import { loadConfig } from "../../config/config.js";
-import { ErrorCodes, errorShape, formatValidationErrors, validateAgentsListParams, } from "../protocol/index.js";
+import { normalizeAgentId } from "../../routing/session-key.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateAgentsFilesGetParams, validateAgentsFilesListParams, validateAgentsFilesSetParams, validateAgentsListParams, } from "../protocol/index.js";
 import { listAgentsForGateway } from "../session-utils.js";
+const BOOTSTRAP_FILE_NAMES = [
+    DEFAULT_AGENTS_FILENAME,
+    DEFAULT_SOUL_FILENAME,
+    DEFAULT_TOOLS_FILENAME,
+    DEFAULT_IDENTITY_FILENAME,
+    DEFAULT_USER_FILENAME,
+    DEFAULT_HEARTBEAT_FILENAME,
+    DEFAULT_BOOTSTRAP_FILENAME,
+];
+const MEMORY_FILE_NAMES = [DEFAULT_MEMORY_FILENAME, DEFAULT_MEMORY_ALT_FILENAME];
+const ALLOWED_FILE_NAMES = new Set([...BOOTSTRAP_FILE_NAMES, ...MEMORY_FILE_NAMES]);
+async function statFile(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        if (!stat.isFile()) {
+            return null;
+        }
+        return {
+            size: stat.size,
+            updatedAtMs: Math.floor(stat.mtimeMs),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function listAgentFiles(workspaceDir) {
+    const files = [];
+    for (const name of BOOTSTRAP_FILE_NAMES) {
+        const filePath = path.join(workspaceDir, name);
+        const meta = await statFile(filePath);
+        if (meta) {
+            files.push({
+                name,
+                path: filePath,
+                missing: false,
+                size: meta.size,
+                updatedAtMs: meta.updatedAtMs,
+            });
+        }
+        else {
+            files.push({ name, path: filePath, missing: true });
+        }
+    }
+    const primaryMemoryPath = path.join(workspaceDir, DEFAULT_MEMORY_FILENAME);
+    const primaryMeta = await statFile(primaryMemoryPath);
+    if (primaryMeta) {
+        files.push({
+            name: DEFAULT_MEMORY_FILENAME,
+            path: primaryMemoryPath,
+            missing: false,
+            size: primaryMeta.size,
+            updatedAtMs: primaryMeta.updatedAtMs,
+        });
+    }
+    else {
+        const altMemoryPath = path.join(workspaceDir, DEFAULT_MEMORY_ALT_FILENAME);
+        const altMeta = await statFile(altMemoryPath);
+        if (altMeta) {
+            files.push({
+                name: DEFAULT_MEMORY_ALT_FILENAME,
+                path: altMemoryPath,
+                missing: false,
+                size: altMeta.size,
+                updatedAtMs: altMeta.updatedAtMs,
+            });
+        }
+        else {
+            files.push({ name: DEFAULT_MEMORY_FILENAME, path: primaryMemoryPath, missing: true });
+        }
+    }
+    return files;
+}
+function resolveAgentIdOrError(agentIdRaw, cfg) {
+    const agentId = normalizeAgentId(agentIdRaw);
+    const allowed = new Set(listAgentIds(cfg));
+    if (!allowed.has(agentId)) {
+        return null;
+    }
+    return agentId;
+}
 export const agentsHandlers = {
     "agents.list": ({ params, respond }) => {
         if (!validateAgentsListParams(params)) {
@@ -11,4 +97,96 @@ export const agentsHandlers = {
         const result = listAgentsForGateway(cfg);
         respond(true, result, undefined);
     },
+    "agents.files.list": async ({ params, respond }) => {
+        if (!validateAgentsFilesListParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agents.files.list params: ${formatValidationErrors(validateAgentsFilesListParams.errors)}`));
+            return;
+        }
+        const cfg = loadConfig();
+        const agentId = resolveAgentIdOrError(String(params.agentId ?? ""), cfg);
+        if (!agentId) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "unknown agent id"));
+            return;
+        }
+        const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+        const files = await listAgentFiles(workspaceDir);
+        respond(true, { agentId, workspace: workspaceDir, files }, undefined);
+    },
+    "agents.files.get": async ({ params, respond }) => {
+        if (!validateAgentsFilesGetParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agents.files.get params: ${formatValidationErrors(validateAgentsFilesGetParams.errors)}`));
+            return;
+        }
+        const cfg = loadConfig();
+        const agentId = resolveAgentIdOrError(String(params.agentId ?? ""), cfg);
+        if (!agentId) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "unknown agent id"));
+            return;
+        }
+        const name = String(params.name ?? "").trim();
+        if (!ALLOWED_FILE_NAMES.has(name)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `unsupported file "${name}"`));
+            return;
+        }
+        const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+        const filePath = path.join(workspaceDir, name);
+        const meta = await statFile(filePath);
+        if (!meta) {
+            respond(true, {
+                agentId,
+                workspace: workspaceDir,
+                file: { name, path: filePath, missing: true },
+            }, undefined);
+            return;
+        }
+        const content = await fs.readFile(filePath, "utf-8");
+        respond(true, {
+            agentId,
+            workspace: workspaceDir,
+            file: {
+                name,
+                path: filePath,
+                missing: false,
+                size: meta.size,
+                updatedAtMs: meta.updatedAtMs,
+                content,
+            },
+        }, undefined);
+    },
+    "agents.files.set": async ({ params, respond }) => {
+        if (!validateAgentsFilesSetParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid agents.files.set params: ${formatValidationErrors(validateAgentsFilesSetParams.errors)}`));
+            return;
+        }
+        const cfg = loadConfig();
+        const agentId = resolveAgentIdOrError(String(params.agentId ?? ""), cfg);
+        if (!agentId) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "unknown agent id"));
+            return;
+        }
+        const name = String(params.name ?? "").trim();
+        if (!ALLOWED_FILE_NAMES.has(name)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `unsupported file "${name}"`));
+            return;
+        }
+        const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+        await fs.mkdir(workspaceDir, { recursive: true });
+        const filePath = path.join(workspaceDir, name);
+        const content = String(params.content ?? "");
+        await fs.writeFile(filePath, content, "utf-8");
+        const meta = await statFile(filePath);
+        respond(true, {
+            ok: true,
+            agentId,
+            workspace: workspaceDir,
+            file: {
+                name,
+                path: filePath,
+                missing: false,
+                size: meta?.size,
+                updatedAtMs: meta?.updatedAtMs,
+                content,
+            },
+        }, undefined);
+    },
 };

package/dist/gateway/server-methods/channels.d.ts

@@ -1,7 +1,7 @@
-import { type ChannelId } from "../../channels/plugins/index.js";
 import type { ChannelPlugin } from "../../channels/plugins/types.js";
 import type { OpenClawConfig } from "../../config/config.js";
 import type { GatewayRequestContext, GatewayRequestHandlers } from "./types.js";
+import { type ChannelId } from "../../channels/plugins/index.js";
 type ChannelLogoutPayload = {
     channel: ChannelId;
     accountId: string;

package/dist/gateway/server-methods/channels.js

@@ -1,6 +1,6 @@
+import { buildChannelUiCatalog } from "../../channels/plugins/catalog.js";
 import { resolveChannelDefaultAccountId } from "../../channels/plugins/helpers.js";
 import { getChannelPlugin, listChannelPlugins, normalizeChannelId, } from "../../channels/plugins/index.js";
-import { buildChannelUiCatalog } from "../../channels/plugins/catalog.js";
 import { buildChannelAccountSnapshot } from "../../channels/plugins/status.js";
 import { loadConfig, readConfigFileSnapshot } from "../../config/config.js";
 import { getChannelActivity } from "../../infra/channel-activity.js";

package/dist/gateway/server-methods/chat.js

@@ -1,10 +1,9 @@
+import { CURRENT_SESSION_VERSION } from "@mariozechner/pi-coding-agent";
 import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { CURRENT_SESSION_VERSION } from "@mariozechner/pi-coding-agent";
 import { resolveSessionAgentId } from "../../agents/agent-scope.js";
 import { resolveEffectiveMessagesConfig, resolveIdentityName } from "../../agents/identity.js";
-import { injectTimestamp, timestampOptsFromConfig } from "./agent-timestamp.js";
 import { resolveThinkingDefault } from "../../agents/model-selection.js";
 import { resolveAgentTimeoutMs } from "../../agents/timeout.js";
 import { dispatchInboundMessage } from "../../auto-reply/dispatch.js";
@@ -14,11 +13,12 @@ import { resolveSendPolicy } from "../../sessions/send-policy.js";
 import { INTERNAL_MESSAGE_CHANNEL } from "../../utils/message-channel.js";
 import { abortChatRunById, abortChatRunsForSessionKey, isChatStopCommandText, resolveChatRunExpiresAtMs, } from "../chat-abort.js";
 import { parseMessageWithAttachments } from "../chat-attachments.js";
+import { stripEnvelopeFromMessages } from "../chat-sanitize.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateChatAbortParams, validateChatHistoryParams, validateChatInjectParams, validateChatSendParams, } from "../protocol/index.js";
 import { getMaxChatHistoryMessagesBytes } from "../server-constants.js";
 import { capArrayByJsonBytes, loadSessionEntry, readSessionMessages, resolveSessionModelRef, } from "../session-utils.js";
-import { stripEnvelopeFromMessages } from "../chat-sanitize.js";
 import { formatForLog } from "../ws-log.js";
+import { injectTimestamp, timestampOptsFromConfig } from "./agent-timestamp.js";
 function resolveTranscriptPath(params) {
     const { sessionId, storePath, sessionFile } = params;
     if (sessionFile) {

package/dist/gateway/server-methods/config.js

@@ -1,11 +1,11 @@
 import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../agents/agent-scope.js";
+import { listChannelPlugins } from "../../channels/plugins/index.js";
 import { CONFIG_PATH, loadConfig, parseConfigJson5, readConfigFileSnapshot, resolveConfigSnapshotHash, validateConfigObjectWithPlugins, writeConfigFile, } from "../../config/config.js";
 import { applyLegacyMigrations } from "../../config/legacy.js";
 import { applyMergePatch } from "../../config/merge-patch.js";
 import { buildConfigSchema } from "../../config/schema.js";
-import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";
 import { formatDoctorNonInteractiveHint, writeRestartSentinel, } from "../../infra/restart-sentinel.js";
-import { listChannelPlugins } from "../../channels/plugins/index.js";
+import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";
 import { loadOpenClawPlugins } from "../../plugins/loader.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateConfigApplyParams, validateConfigGetParams, validateConfigPatchParams, validateConfigSchemaParams, validateConfigSetParams, } from "../protocol/index.js";
 function resolveBaseHash(params) {

package/dist/gateway/server-methods/nodes.js

@@ -1,9 +1,9 @@
-import { approveNodePairing, listNodePairing, rejectNodePairing, renamePairedNode, requestNodePairing, verifyNodeToken, } from "../../infra/node-pairing.js";
+import { loadConfig } from "../../config/config.js";
 import { listDevicePairing } from "../../infra/device-pairing.js";
+import { approveNodePairing, listNodePairing, rejectNodePairing, renamePairedNode, requestNodePairing, verifyNodeToken, } from "../../infra/node-pairing.js";
+import { isNodeCommandAllowed, resolveNodeCommandAllowlist } from "../node-command-policy.js";
 import { ErrorCodes, errorShape, validateNodeDescribeParams, validateNodeEventParams, validateNodeInvokeParams, validateNodeInvokeResultParams, validateNodeListParams, validateNodePairApproveParams, validateNodePairListParams, validateNodePairRejectParams, validateNodePairRequestParams, validateNodePairVerifyParams, validateNodeRenameParams, } from "../protocol/index.js";
 import { respondInvalidParams, respondUnavailableOnThrow, safeParseJson, uniqueSortedStrings, } from "./nodes.helpers.js";
-import { loadConfig } from "../../config/config.js";
-import { isNodeCommandAllowed, resolveNodeCommandAllowlist } from "../node-command-policy.js";
 function isNodeEntry(entry) {
     if (entry.role === "node") {
         return true;

package/dist/gateway/server-methods/send.js

@@ -1,11 +1,11 @@
+import { resolveSessionAgentId } from "../../agents/agent-scope.js";
 import { getChannelPlugin, normalizeChannelId } from "../../channels/plugins/index.js";
 import { DEFAULT_CHAT_CHANNEL } from "../../channels/registry.js";
-import { loadConfig } from "../../config/config.js";
 import { createOutboundSendDeps } from "../../cli/deps.js";
+import { loadConfig } from "../../config/config.js";
 import { deliverOutboundPayloads } from "../../infra/outbound/deliver.js";
-import { normalizeReplyPayloadsForDelivery } from "../../infra/outbound/payloads.js";
 import { ensureOutboundSessionEntry, resolveOutboundSessionRoute, } from "../../infra/outbound/outbound-session.js";
-import { resolveSessionAgentId } from "../../agents/agent-scope.js";
+import { normalizeReplyPayloadsForDelivery } from "../../infra/outbound/payloads.js";
 import { resolveOutboundTarget } from "../../infra/outbound/targets.js";
 import { normalizePollInput } from "../../polls.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validatePollParams, validateSendParams, } from "../protocol/index.js";