@pushary/openclaw 0.0.0-stage → 0.1.1

package/dist/protected-writes.js

@@ -0,0 +1,217 @@
+import { realpathSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const WRITE_TOOL = 'write';
+export const EDIT_TOOL = 'edit';
+export const APPLY_PATCH_TOOL = 'apply_patch';
+export const FILE_WRITING_TOOLS = [WRITE_TOOL, EDIT_TOOL, APPLY_PATCH_TOOL];
+const PATH_PARAMETER = 'path';
+const PATCH_PARAMETER = 'input';
+const PATCH_TARGET_MARKERS = ['*** Add File: ', '*** Delete File: ', '*** Update File: ', '*** Move to: '];
+const PATCH_MARKER_PREFIX = '***';
+const FILE_URL_PREFIX = 'file://';
+const FILE_REFERENCE_PREFIX = '@';
+const HOME_PREFIX = '~';
+const MISSING_PATH_CODES = new Set(['ENOENT', 'ENOTDIR']);
+const WORKSPACE_HOOKS_DIRECTORY = 'hooks';
+const RISKY_RELATIVE_STARTS = ['.pushary', '.config'];
+const errorCodeOf = (error) => typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string' ? error.code : null;
+const canonicalPathOf = (path, system) => {
+    const missing = [];
+    let current = normalize(path);
+    for (;;) {
+        try {
+            const real = system.realpath(current);
+            return missing.length === 0 ? real : join(real, ...missing.reverse());
+        }
+        catch (error) {
+            const code = errorCodeOf(error);
+            const parent = dirname(current);
+            if (code === null || !MISSING_PATH_CODES.has(code) || parent === current)
+                return null;
+            missing.push(basename(current));
+            current = parent;
+        }
+    }
+};
+const comparable = (path, system) => {
+    const composed = path.normalize('NFC');
+    return system.caseInsensitive ? composed.toLowerCase() : composed;
+};
+const spellingsOfLocation = (path, system) => {
+    const canonical = canonicalPathOf(path, system);
+    const resolved = comparable(resolve(path), system);
+    return canonical === null ? [resolved] : [...new Set([comparable(canonical, system), resolved])];
+};
+const spellingsOfAll = (paths, system) => [...new Set(paths.flatMap(path => spellingsOfLocation(path, system)))];
+const isSameOrInside = (path, directory) => path === directory || path.startsWith(directory.endsWith(sep) ? directory : `${directory}${sep}`);
+const isStrictlyInside = (path, directory) => path !== directory && isSameOrInside(path, directory);
+const firstComponentUnder = (path, directory) => {
+    if (!isStrictlyInside(path, directory))
+        return null;
+    return relative(directory, path).split(sep)[0] ?? null;
+};
+const comparablePathsFor = (locations, system, agentId) => {
+    const stateDirectories = spellingsOfAll(locations.stateDirectories, system);
+    const workspace = system.workspaceFor(agentId);
+    const workspaceCanonical = workspace === null ? null : canonicalPathOf(workspace, system);
+    return {
+        stateDirectories,
+        configFiles: spellingsOfAll(locations.configFiles, system),
+        protectedTrees: spellingsOfAll(locations.protectedTrees, system),
+        serviceFiles: locations.serviceFiles.flatMap(location => spellingsOfLocation(location.directory, system).map(directory => ({ directory, namePrefix: comparable(location.namePrefix, system) }))),
+        workspace: workspaceCanonical === null ? null : comparable(workspaceCanonical, system),
+        riskyRelativeStarts: new Set([
+            ...locations.stateDirectories.map(state => comparable(basename(state), system)),
+            ...locations.configFiles.map(file => comparable(basename(file), system)),
+            ...RISKY_RELATIVE_STARTS.map(start => comparable(start, system)),
+        ]),
+    };
+};
+const isServiceFile = (path, services) => services.some(service => firstComponentUnder(path, service.directory)?.startsWith(service.namePrefix) === true);
+const isInWorkspaceHooks = (path, workspace) => workspace !== null && firstComponentUnder(path, workspace) === WORKSPACE_HOOKS_DIRECTORY;
+const isInWorkspaceUnderState = (path, paths) => {
+    const { workspace } = paths;
+    if (workspace === null || !isSameOrInside(path, workspace))
+        return false;
+    return paths.stateDirectories.some(state => isStrictlyInside(workspace, state));
+};
+const isProtectedLocation = (path, paths) => {
+    if (paths.configFiles.includes(path))
+        return true;
+    if (paths.protectedTrees.some(tree => isSameOrInside(path, tree)))
+        return true;
+    if (isServiceFile(path, paths.serviceFiles))
+        return true;
+    if (isInWorkspaceHooks(path, paths.workspace))
+        return true;
+    if (!paths.stateDirectories.some(state => isSameOrInside(path, state)))
+        return false;
+    return !isInWorkspaceUnderState(path, paths);
+};
+const verdictForAbsolute = (path, paths, system) => {
+    const canonical = canonicalPathOf(path, system);
+    if (canonical === null)
+        return 'uncertain';
+    return isProtectedLocation(comparable(canonical, system), paths) ? 'protected' : 'clear';
+};
+const firstComponentOf = (relativePath) => normalize(relativePath).split(/[\\/]/).find(part => part.length > 0) ?? '';
+const expandedHome = (path, osHome) => path === HOME_PREFIX || path.startsWith(`${HOME_PREFIX}/`) || (process.platform === 'win32' && path.startsWith(`${HOME_PREFIX}\\`))
+    ? join(osHome, path.slice(HOME_PREFIX.length))
+    : path;
+const spellingsOf = (raw) => {
+    if (!raw.startsWith(FILE_REFERENCE_PREFIX))
+        return [raw];
+    const referenced = raw.slice(FILE_REFERENCE_PREFIX.length);
+    return [referenced.startsWith(FILE_REFERENCE_PREFIX) ? `./${referenced}` : referenced, `./${raw}`];
+};
+const absoluteOrRelative = (spelling, osHome) => {
+    if (!spelling.startsWith(FILE_URL_PREFIX))
+        return expandedHome(spelling, osHome);
+    try {
+        return fileURLToPath(spelling);
+    }
+    catch {
+        return null;
+    }
+};
+const worstOf = (verdicts) => {
+    if (verdicts.includes('protected'))
+        return 'protected';
+    if (verdicts.length === 0 || verdicts.includes('uncertain'))
+        return 'uncertain';
+    return 'clear';
+};
+const PARENT_SEGMENT = '..';
+const leadingClimbsOf = (relativePath) => {
+    const parts = normalize(relativePath).split(/[\\/]/);
+    const firstOther = parts.findIndex(part => part !== PARENT_SEGMENT);
+    return firstOther === -1 ? parts.length : firstOther;
+};
+const ancestorsUpTo = (directory, levels) => {
+    const ancestors = [directory];
+    for (let level = 0; level < levels; level += 1)
+        ancestors.push(dirname(ancestors[ancestors.length - 1] ?? directory));
+    return ancestors;
+};
+const landingPlacesOf = (relativePath, workspace, others) => {
+    const climbs = leadingClimbsOf(relativePath);
+    const rest = normalize(relativePath).split(/[\\/]/).slice(climbs).join(sep);
+    const fromInsideTheWorkspace = ancestorsUpTo(workspace, climbs).map(base => join(base, rest));
+    return [...fromInsideTheWorkspace, resolve(workspace, relativePath), ...others.map(directory => resolve(directory, relativePath))];
+};
+const verdictForSpelling = (spelling, paths, system) => {
+    const path = absoluteOrRelative(spelling, system.osHome);
+    if (path === null || path.trim().length === 0)
+        return 'uncertain';
+    if (isAbsolute(path))
+        return verdictForAbsolute(path, paths, system);
+    if (paths.riskyRelativeStarts.has(comparable(firstComponentOf(path), system)))
+        return 'protected';
+    if (paths.workspace === null)
+        return 'uncertain';
+    return worstOf(landingPlacesOf(path, paths.workspace, system.otherWorkingDirectories).map(place => verdictForAbsolute(place, paths, system)));
+};
+const verdictForRawPath = (raw, paths, system) => {
+    if (typeof raw !== 'string' || raw.trim().length === 0)
+        return 'uncertain';
+    return worstOf(spellingsOf(raw.trim()).map(spelling => verdictForSpelling(spelling, paths, system)));
+};
+const patchTargetOf = (line) => {
+    const header = line.trimStart();
+    if (!header.startsWith(PATCH_MARKER_PREFIX))
+        return null;
+    const trimmed = header.trimEnd();
+    const marker = PATCH_TARGET_MARKERS.find(candidate => trimmed.startsWith(candidate));
+    return marker === undefined ? null : trimmed.slice(marker.length);
+};
+export const patchTargetsOf = (patch) => typeof patch === 'string' ? patch.split(/\r?\n/).flatMap(line => {
+    const target = patchTargetOf(line);
+    return target === null ? [] : [target];
+}) : [];
+const hostResolvedPathsOf = (event) => Array.isArray(event.derivedPaths) ? event.derivedPaths : [];
+const rawTargetsOf = (toolId, event) => {
+    if (toolId === APPLY_PATCH_TOOL) {
+        const targets = [...patchTargetsOf(event.params[PATCH_PARAMETER]), ...hostResolvedPathsOf(event)];
+        return targets.length === 0 ? null : targets;
+    }
+    return [event.params[PATH_PARAMETER]];
+};
+export const writesIntoOpenClaw = (locations, system, call) => {
+    if (!FILE_WRITING_TOOLS.includes(call.toolId))
+        return false;
+    const targets = rawTargetsOf(call.toolId, call.event);
+    if (targets === null)
+        return true;
+    const paths = comparablePathsFor(locations, system, call.agentId);
+    return targets.some(target => verdictForRawPath(target, paths, system) !== 'clear');
+};
+export const SESSIONS_SPAWN_TOOL = 'sessions_spawn';
+export const SPAWN_FOLDER_PARAMETER = 'cwd';
+const SPAWN_SOURCES_IT_CANNOT_SEE = ['projectId', 'projectGitUrl', 'worktree'];
+const namesAFolderItCannotSee = (params) => SPAWN_SOURCES_IT_CANNOT_SEE.some(name => params[name] !== undefined && params[name] !== false);
+const spawnFolderVerdict = (raw, paths, system) => {
+    if (typeof raw !== 'string' || raw.trim().length === 0 || paths.workspace === null)
+        return 'uncertain';
+    const expanded = absoluteOrRelative(raw.trim(), system.osHome);
+    if (expanded === null)
+        return 'uncertain';
+    const canonical = canonicalPathOf(resolve(paths.workspace, expanded), system);
+    if (canonical === null)
+        return 'uncertain';
+    const folder = comparable(canonical, system);
+    if (!isSameOrInside(folder, paths.workspace))
+        return 'protected';
+    return isInWorkspaceHooks(folder, paths.workspace) ? 'protected' : 'clear';
+};
+export const spawnsOutsideTheWorkspace = (locations, system, call) => {
+    if (call.toolId !== SESSIONS_SPAWN_TOOL)
+        return false;
+    const { params } = call.event;
+    if (namesAFolderItCannotSee(params))
+        return true;
+    if (params[SPAWN_FOLDER_PARAMETER] === undefined)
+        return false;
+    return spawnFolderVerdict(params[SPAWN_FOLDER_PARAMETER], comparablePathsFor(locations, system, call.agentId), system) !== 'clear';
+};
+export const nodeRealpath = (path) => realpathSync(path);

package/dist/pushary-client.d.ts

@@ -0,0 +1,42 @@
+import type { PusharyConnection } from './connection.js';
+export declare const MCP_PATH = "/api/mcp/mcp";
+export declare const ASK_USER_TOOL = "ask_user";
+export declare const WAIT_FOR_ANSWER_TOOL = "wait_for_answer";
+export declare const CANCEL_QUESTION_TOOL = "cancel_question";
+export declare const ASK_REQUEST_TIMEOUT_MS = 10000;
+export declare const CANCEL_REQUEST_TIMEOUT_MS = 4000;
+export declare const POLL_TIMEOUT_MIN_MS = 1000;
+export declare const POLL_TIMEOUT_MAX_MS = 30000;
+export declare const POLL_RESPONSE_GRACE_MS = 2000;
+export type CallFailure = 'aborted' | 'timed_out' | 'network' | 'unauthorized' | 'refused' | 'server_error' | 'unreadable' | 'tool_error';
+export type CallResult = {
+    readonly kind: 'reply';
+    readonly value: unknown;
+} | {
+    readonly kind: 'failed';
+    readonly failure: CallFailure;
+};
+export interface AskUserArguments {
+    readonly question: string;
+    readonly type: 'confirm';
+    readonly wait: false;
+    readonly context: string;
+    readonly agentName: string;
+    readonly toolName: string;
+    readonly action: string;
+    readonly actionBody: string;
+    readonly waitEndsAt: string;
+    readonly localSurfaceAvailable: false;
+    readonly toolTarget?: string;
+    readonly sessionId?: string;
+    readonly machineId?: string;
+    readonly requestId: string;
+}
+export interface PusharyQuestions {
+    readonly ask: (args: AskUserArguments) => Promise<CallResult>;
+    readonly waitForAnswer: (correlationId: string, timeoutMs: number, signal: AbortSignal | undefined) => Promise<CallResult>;
+    readonly cancel: (correlationId: string) => Promise<CallResult>;
+}
+export type Fetcher = (input: string, init: RequestInit) => Promise<Response>;
+export declare const clampedPollMs: (timeoutMs: number) => number;
+export declare const createPusharyQuestions: (connection: PusharyConnection, fetcher?: Fetcher) => PusharyQuestions;

package/dist/pushary-client.js

@@ -0,0 +1,103 @@
+export const MCP_PATH = '/api/mcp/mcp';
+export const ASK_USER_TOOL = 'ask_user';
+export const WAIT_FOR_ANSWER_TOOL = 'wait_for_answer';
+export const CANCEL_QUESTION_TOOL = 'cancel_question';
+export const ASK_REQUEST_TIMEOUT_MS = 10_000;
+export const CANCEL_REQUEST_TIMEOUT_MS = 4_000;
+export const POLL_TIMEOUT_MIN_MS = 1_000;
+export const POLL_TIMEOUT_MAX_MS = 30_000;
+export const POLL_RESPONSE_GRACE_MS = 2_000;
+const JSON_RPC_VERSION = '2.0';
+const TOOLS_CALL_METHOD = 'tools/call';
+const EVENT_STREAM_TYPE = 'text/event-stream';
+const EVENT_DATA_PREFIX = 'data:';
+const UNAUTHORIZED_STATUSES = new Set([401, 403]);
+const TOO_MANY_REQUESTS_STATUS = 429;
+const SERVER_ERROR_STATUS_FLOOR = 500;
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const parsedJson = (text) => {
+    try {
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch {
+        return { ok: false };
+    }
+};
+const lastEventData = (stream) => {
+    const events = stream.split(/\r?\n\r?\n/).map(event => event.split(/\r?\n/).filter(line => line.startsWith(EVENT_DATA_PREFIX)).map(line => line.slice(EVENT_DATA_PREFIX.length).trimStart()).join('\n').trim());
+    return events.filter(data => data.length > 0).at(-1) ?? null;
+};
+const envelopeOf = (body, contentType) => {
+    const text = contentType.includes(EVENT_STREAM_TYPE) ? lastEventData(body) : body;
+    if (text === null || text.trim().length === 0)
+        return null;
+    const parsed = parsedJson(text);
+    return parsed.ok ? parsed.value : null;
+};
+const firstTextContent = (content) => {
+    if (!Array.isArray(content))
+        return null;
+    const first = content[0];
+    return isRecord(first) && typeof first.text === 'string' ? first.text : null;
+};
+const toolReplyOf = (envelope) => {
+    if (!isRecord(envelope))
+        return { kind: 'failed', failure: 'unreadable' };
+    if (envelope.error !== undefined)
+        return { kind: 'failed', failure: 'tool_error' };
+    const result = envelope.result;
+    if (!isRecord(result))
+        return { kind: 'failed', failure: 'unreadable' };
+    if (result.isError === true)
+        return { kind: 'failed', failure: 'tool_error' };
+    if (isRecord(result.structuredContent))
+        return { kind: 'reply', value: result.structuredContent };
+    const text = firstTextContent(result.content);
+    const parsed = text === null ? null : parsedJson(text);
+    return parsed?.ok ? { kind: 'reply', value: parsed.value } : { kind: 'failed', failure: 'unreadable' };
+};
+const requestSignal = (signal, timeoutMs) => {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    return signal ? AbortSignal.any([signal, timeout]) : timeout;
+};
+const httpFailureOf = (status) => {
+    if (UNAUTHORIZED_STATUSES.has(status))
+        return 'unauthorized';
+    return status === TOO_MANY_REQUESTS_STATUS || status >= SERVER_ERROR_STATUS_FLOOR ? 'server_error' : 'refused';
+};
+export const clampedPollMs = (timeoutMs) => Math.min(Math.max(Math.floor(timeoutMs), POLL_TIMEOUT_MIN_MS), POLL_TIMEOUT_MAX_MS);
+export const createPusharyQuestions = (connection, fetcher = fetch) => {
+    const endpoint = `${connection.baseUrl}${MCP_PATH}`;
+    const callTool = async (name, args, timeoutMs, signal) => {
+        const combined = requestSignal(signal, timeoutMs);
+        try {
+            const response = await fetcher(endpoint, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Accept: `application/json, ${EVENT_STREAM_TYPE}`,
+                    Authorization: `Bearer ${connection.apiKey}`,
+                },
+                body: JSON.stringify({ jsonrpc: JSON_RPC_VERSION, id: 1, method: TOOLS_CALL_METHOD, params: { name, arguments: args } }),
+                signal: combined,
+            });
+            if (!response.ok)
+                return { kind: 'failed', failure: httpFailureOf(response.status) };
+            const body = await response.text();
+            return toolReplyOf(envelopeOf(body, response.headers.get('content-type') ?? ''));
+        }
+        catch {
+            if (signal?.aborted)
+                return { kind: 'failed', failure: 'aborted' };
+            return { kind: 'failed', failure: combined.aborted ? 'timed_out' : 'network' };
+        }
+    };
+    return {
+        ask: args => callTool(ASK_USER_TOOL, { ...args }, ASK_REQUEST_TIMEOUT_MS, undefined),
+        waitForAnswer: (correlationId, timeoutMs, signal) => {
+            const pollMs = clampedPollMs(timeoutMs);
+            return callTool(WAIT_FOR_ANSWER_TOOL, { correlationId, timeoutMs: pollMs }, pollMs + POLL_RESPONSE_GRACE_MS, signal);
+        },
+        cancel: correlationId => callTool(CANCEL_QUESTION_TOOL, { correlationId }, CANCEL_REQUEST_TIMEOUT_MS, undefined),
+    };
+};

package/dist/pushary-hosts.d.ts

@@ -0,0 +1,2 @@
+export declare const PUSHARY_HOSTS: readonly string[];
+export declare const isPusharyHost: (hostname: string) => boolean;

package/dist/pushary-hosts.js

@@ -0,0 +1,3 @@
+// Generated by scripts/generate-editor-redaction.mjs.
+export const PUSHARY_HOSTS = ['pushary.com', 'www.pushary.com'];
+export const isPusharyHost = (hostname) => PUSHARY_HOSTS.includes(hostname);

package/dist/redaction.d.ts

@@ -0,0 +1,9 @@
+interface RedactionRule {
+    readonly pattern: RegExp;
+    readonly replacement: string;
+}
+export declare const SECRET_REDACTION_RULES: readonly RedactionRule[];
+export declare const redactSecrets: (text: string) => string;
+export declare const redactSecretsFromContent: (text: string) => string;
+export declare const redactSecretsDeep: (text: string) => string;
+export {};

package/dist/redaction.js

@@ -0,0 +1,53 @@
+const CREDENTIAL_NAME = String.raw `(?:authorization|secret|token|password|passwd|api[_-]?key|access[_-]?key|client[_-]?secret|private[_-]?key)["']?`;
+const CREDENTIAL_KEY = String.raw `${CREDENTIAL_NAME}\s*[=:]\s*`;
+const DISPLAYED_CREDENTIAL_KEY = String.raw `${CREDENTIAL_NAME}(?:[ \t]*:[ \t]*|[ \t]+=[ \t]*|=)`;
+const SHELL_INERT_UNIT = String.raw `(?:[A-Za-z0-9_\-./+=:@%^!#]|\\[^\s'"])`;
+const SHELL_INERT_SINGLE_QUOTED_UNIT = String.raw `[A-Za-z0-9_\-./+=:@%^!#\\]`;
+const SHELL_INERT_URL_PASSWORD_UNIT = String.raw `(?:[A-Za-z0-9_\-.+=:%^!#]|\\[^\s'"@/])`;
+const AUTHORIZATION_SCHEME = String.raw `(?:basic|digest|token|negotiate|ntlm)`;
+const PEM_LINE_BREAK = String.raw `(?:\r?\n|(?:\\r)?\\n)`;
+const credentialAssignmentRule = (key, doubleQuoted, singleQuoted, bare) => ({
+    pattern: new RegExp(String.raw `(${key})(?:(")${doubleQuoted}|(')${singleQuoted}|(["']?)${bare})`, 'gi'),
+    replacement: '$1$2$3$4[redacted]$2$3',
+});
+const DISPLAYED_SECRET_SHAPES = {
+    separator: String.raw `[ \t]`,
+    privateKeyBody: String.raw `${PEM_LINE_BREAK}?(?:(?:Proc-Type|DEK-Info): [A-Za-z0-9,-]+${PEM_LINE_BREAK})*(?:[A-Za-z0-9+/=\r\n]|\\[rn])*?`,
+    urlPassword: `${SHELL_INERT_URL_PASSWORD_UNIT}+`,
+    authorizationValue: `${SHELL_INERT_UNIT}+`,
+    credentialAssignment: credentialAssignmentRule(DISPLAYED_CREDENTIAL_KEY, `${SHELL_INERT_UNIT}*"`, `${SHELL_INERT_SINGLE_QUOTED_UNIT}*'`, `${SHELL_INERT_UNIT}+`),
+};
+const CUT_OFF_SECRET_SHAPES = {
+    separator: String.raw `\s`,
+    privateKeyBody: String.raw `[\s\S]*?`,
+    urlPassword: String.raw `[^\s@/]+`,
+    authorizationValue: String.raw `\S+`,
+    credentialAssignment: credentialAssignmentRule(CREDENTIAL_KEY, String.raw `(?:\\[\s\S]|[^"\\])*(?:"|\\?$)`, "[^']*(?:'|$)", String.raw `\S+`),
+};
+const secretRedactionRules = (shapes) => [
+    { pattern: /\bpk_[A-Za-z0-9_]+\.[A-Za-z0-9_]+/g, replacement: '[redacted]' },
+    { pattern: new RegExp(String.raw `-----BEGIN[A-Z0-9 ]*PRIVATE KEY-----${shapes.privateKeyBody}-----END[A-Z0-9 ]*PRIVATE KEY-----`, 'g'), replacement: '[redacted key]' },
+    { pattern: /\bsk-[A-Za-z0-9_-]{16,}\b/g, replacement: '[redacted]' },
+    { pattern: /\b[spr]k_(?:live|test)_[A-Za-z0-9]{8,}\b/g, replacement: '[redacted]' },
+    { pattern: /\bwhsec_[A-Za-z0-9]{16,}\b/g, replacement: '[redacted]' },
+    { pattern: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}\b/g, replacement: '[redacted]' },
+    { pattern: /\bgithub_pat_[A-Za-z0-9_]{22,}\b/g, replacement: '[redacted]' },
+    { pattern: /\bglpat-[A-Za-z0-9_-]{20,}\b/g, replacement: '[redacted]' },
+    { pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, replacement: '[redacted]' },
+    { pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g, replacement: '[redacted]' },
+    { pattern: /\bAKIA[0-9A-Z]{16}\b/g, replacement: '[redacted]' },
+    { pattern: /\bnpm_[A-Za-z0-9]{36}\b/g, replacement: '[redacted]' },
+    { pattern: /\bxai-[A-Za-z0-9]{16,}\b/g, replacement: '[redacted]' },
+    { pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, replacement: '[redacted]' },
+    { pattern: new RegExp(String.raw `\b([a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:)${shapes.urlPassword}@`, 'gi'), replacement: '$1[redacted]@' },
+    { pattern: new RegExp(String.raw `\bbearer${shapes.separator}+[A-Za-z0-9._~+/=-]+`, 'gi'), replacement: 'bearer [redacted]' },
+    { pattern: new RegExp(String.raw `\bauthorization:${shapes.separator}*(?:${AUTHORIZATION_SCHEME}${shapes.separator}+)?${shapes.authorizationValue}`, 'gi'), replacement: 'authorization: [redacted]' },
+    shapes.credentialAssignment,
+];
+export const SECRET_REDACTION_RULES = secretRedactionRules(DISPLAYED_SECRET_SHAPES);
+const CUT_OFF_TEXT_REDACTION_RULES = secretRedactionRules(CUT_OFF_SECRET_SHAPES);
+const HIGH_ENTROPY_RULE = { pattern: /[A-Za-z0-9+/]{40,}={0,2}/g, replacement: '[redacted]' };
+const applyRedactionRules = (rules, text) => rules.reduce((acc, rule) => acc.replace(rule.pattern, rule.replacement), text);
+export const redactSecrets = (text) => applyRedactionRules(SECRET_REDACTION_RULES, text);
+export const redactSecretsFromContent = (text) => applyRedactionRules(CUT_OFF_TEXT_REDACTION_RULES, text);
+export const redactSecretsDeep = (text) => redactSecrets(text).replace(HIGH_ENTROPY_RULE.pattern, HIGH_ENTROPY_RULE.replacement);

package/dist/replies.d.ts

@@ -0,0 +1,33 @@
+export declare const CANCEL_THEN_ASK_IN_CURRENT_CLIENT = "cancel_then_ask_in_current_client";
+export declare const PUSH_FIRST_DELIVERY = "push_first";
+export type HandBackReason = 'no_devices' | 'current_client';
+export type QuestionState = {
+    readonly kind: 'answered';
+    readonly value: string;
+} | {
+    readonly kind: 'stopped';
+} | {
+    readonly kind: 'ended';
+} | {
+    readonly kind: 'hand_back';
+    readonly reason: HandBackReason;
+} | {
+    readonly kind: 'pending';
+} | {
+    readonly kind: 'unreadable';
+};
+export type AskReply = {
+    readonly kind: 'question';
+    readonly correlationId: string;
+    readonly state: QuestionState;
+    readonly handBackAfterMs: number | null;
+} | {
+    readonly kind: 'stopped';
+} | {
+    readonly kind: 'unreadable';
+};
+export type Withdrawal = 'withdrawn' | 'not_pending' | 'stop' | 'unreachable';
+export declare const questionStateOf: (reply: unknown) => QuestionState;
+export declare const askReplyOf: (reply: unknown) => AskReply;
+export declare const withdrawalOf: (reply: unknown) => Withdrawal;
+export declare const isExplicitApproval: (answer: string) => boolean;

package/dist/replies.js

@@ -0,0 +1,65 @@
+import { isApprovingAnswer, isDecisionStoppedReply, STOP_HANDOFF_ACTION } from './decision-reply.js';
+export const CANCEL_THEN_ASK_IN_CURRENT_CLIENT = 'cancel_then_ask_in_current_client';
+export const PUSH_FIRST_DELIVERY = 'push_first';
+const PENDING_STATUS = 'pending';
+const UNAVAILABLE_STATUS = 'unavailable';
+const ENDED_STATUSES = new Set(['expired']);
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const answeredValueOf = (reply) => reply.answered === true && typeof reply.value === 'string' ? reply.value : null;
+const statusOf = (reply) => (typeof reply.status === 'string' ? reply.status : null);
+const hasEnded = (reply) => {
+    const status = statusOf(reply);
+    return status !== null && ENDED_STATUSES.has(status);
+};
+const handBackReasonOf = (reply) => reply.noDevices === true ? 'no_devices' : 'current_client';
+export const questionStateOf = (reply) => {
+    if (!isRecord(reply))
+        return { kind: 'unreadable' };
+    if (isDecisionStoppedReply(reply))
+        return { kind: 'stopped' };
+    const answered = answeredValueOf(reply);
+    if (answered !== null)
+        return { kind: 'answered', value: answered };
+    if (reply.answered === true)
+        return { kind: 'unreadable' };
+    if (hasEnded(reply))
+        return { kind: 'ended' };
+    if (reply.handoffAction === CANCEL_THEN_ASK_IN_CURRENT_CLIENT)
+        return { kind: 'hand_back', reason: handBackReasonOf(reply) };
+    if (statusOf(reply) === PENDING_STATUS)
+        return { kind: 'pending' };
+    return { kind: 'unreadable' };
+};
+const correlationIdOf = (reply) => typeof reply.correlationId === 'string' && reply.correlationId.trim().length > 0 ? reply.correlationId : null;
+const handBackAfterMsOf = (reply) => {
+    if (reply.requesterMayAnswer === false || reply.deliveryMode !== PUSH_FIRST_DELIVERY)
+        return null;
+    const window = reply.policyTimeoutMs;
+    return typeof window === 'number' && Number.isFinite(window) && window >= 0 ? window : null;
+};
+export const askReplyOf = (reply) => {
+    if (!isRecord(reply))
+        return { kind: 'unreadable' };
+    const state = questionStateOf(reply);
+    if (state.kind === 'stopped')
+        return { kind: 'stopped' };
+    const correlationId = correlationIdOf(reply);
+    if (correlationId === null)
+        return { kind: 'unreadable' };
+    return { kind: 'question', correlationId, state, handBackAfterMs: handBackAfterMsOf(reply) };
+};
+export const withdrawalOf = (reply) => {
+    if (!isRecord(reply))
+        return 'unreachable';
+    if (statusOf(reply) === UNAVAILABLE_STATUS || reply.handoffAction === STOP_HANDOFF_ACTION)
+        return 'stop';
+    if (typeof reply.cancelled !== 'boolean')
+        return 'unreachable';
+    const byThisCall = reply.cancelledByThisCall;
+    if (byThisCall !== undefined && typeof byThisCall !== 'boolean')
+        return 'unreachable';
+    if (byThisCall === true && !reply.cancelled)
+        return 'unreachable';
+    return reply.cancelled ? 'withdrawn' : 'not_pending';
+};
+export const isExplicitApproval = (answer) => isApprovingAnswer(answer);

package/dist/settings.d.ts

@@ -0,0 +1,34 @@
+import type { OpenClawBeforeToolCallEvent, OpenClawToolMatcher } from './host-api.js';
+export declare const PLUGIN_ID = "pushary";
+export declare const PLUGIN_NAME = "Pushary";
+export declare const PLUGIN_DESCRIPTION = "Asks you on your phone before OpenClaw runs a gated tool call, and blocks the call unless you approve it.";
+export declare const AGENT_LABEL = "OpenClaw";
+export declare const DEFAULT_OPENCLAW_AGENT_ID = "main";
+export declare const EXEC_TOOL = "exec";
+export declare const PROCESS_TOOL = "process";
+export declare const PLUGINS_TOOL = "plugins";
+export declare const GATEWAY_TOOL = "gateway";
+export declare const OPENCLAW_SYSTEM_TOOL = "openclaw";
+export declare const AUTOMATIONS_TOOL = "automations";
+export declare const TERMINAL_TOOL = "terminal";
+export declare const TOOL_ACTION_PARAMETER = "action";
+export declare const DEFAULT_GATED_TOOLS: readonly string[];
+export interface GateSettings {
+    readonly gatedTools: readonly string[];
+}
+export type SettingsReading = {
+    readonly kind: 'defaulted';
+    readonly settings: GateSettings;
+} | {
+    readonly kind: 'configured';
+    readonly settings: GateSettings;
+    readonly rejected: readonly string[];
+} | {
+    readonly kind: 'invalid';
+    readonly settings: GateSettings;
+};
+export declare const hostToolId: (name: string) => string;
+export declare const readGateSettings: (pluginConfig: unknown) => SettingsReading;
+export declare const hookMatcherFor: (settings: GateSettings) => OpenClawToolMatcher;
+export declare const needsApproval: (settings: GateSettings, event: OpenClawBeforeToolCallEvent) => boolean;
+export declare const askingAgentName: (openClawAgentId: string | undefined) => string;