@sheepbun/yips 0.1.1

package/dist/gateway/adapters/whatsapp.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppAdapter = void 0;
+const formatting_1 = require("#gateway/adapters/formatting");
+const DEFAULT_API_BASE_URL = "https://graph.facebook.com";
+const DEFAULT_API_VERSION = "v21.0";
+const DEFAULT_MAX_MESSAGE_LENGTH = 4000;
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function parseTimestamp(value) {
+    if (!value) {
+        return undefined;
+    }
+    const seconds = Number.parseInt(value, 10);
+    if (!Number.isFinite(seconds)) {
+        return undefined;
+    }
+    return new Date(seconds * 1000);
+}
+function findContactByWaId(contacts, waId) {
+    if (!contacts || contacts.length === 0) {
+        return undefined;
+    }
+    return contacts.find((contact) => contact.wa_id === waId);
+}
+function toInboundMessage(message, value, entryId) {
+    if (message.type !== "text") {
+        return null;
+    }
+    const senderId = message.from;
+    const text = message.text?.body;
+    if (typeof senderId !== "string" || typeof text !== "string") {
+        return null;
+    }
+    const contact = findContactByWaId(value.contacts, senderId);
+    return {
+        platform: "whatsapp",
+        senderId,
+        channelId: value.metadata?.phone_number_id,
+        text,
+        messageId: message.id,
+        timestamp: parseTimestamp(message.timestamp),
+        metadata: {
+            waId: contact?.wa_id ?? senderId,
+            profileName: contact?.profile?.name,
+            displayPhoneNumber: value.metadata?.display_phone_number,
+            phoneNumberId: value.metadata?.phone_number_id,
+            entryId
+        }
+    };
+}
+function parseInboundMessages(payload) {
+    if (!isObject(payload)) {
+        return [];
+    }
+    const envelope = payload;
+    if (!Array.isArray(envelope.entry)) {
+        return [];
+    }
+    const messages = [];
+    for (const entry of envelope.entry) {
+        if (!Array.isArray(entry.changes)) {
+            continue;
+        }
+        for (const change of entry.changes) {
+            const value = change.value;
+            if (!value || !Array.isArray(value.messages)) {
+                continue;
+            }
+            for (const message of value.messages) {
+                const inbound = toInboundMessage(message, value, entry.id);
+                if (inbound) {
+                    messages.push(inbound);
+                }
+            }
+        }
+    }
+    return messages;
+}
+class WhatsAppAdapter {
+    platform = "whatsapp";
+    accessToken;
+    phoneNumberId;
+    apiBaseUrl;
+    apiVersion;
+    maxMessageLength;
+    constructor(options) {
+        this.accessToken = options.accessToken.trim();
+        this.phoneNumberId = options.phoneNumberId.trim();
+        this.apiBaseUrl = (options.apiBaseUrl ?? DEFAULT_API_BASE_URL).trim().replace(/\/+$/, "");
+        this.apiVersion = (options.apiVersion ?? DEFAULT_API_VERSION).trim();
+        this.maxMessageLength = Math.max(1, Math.trunc(options.maxMessageLength ?? DEFAULT_MAX_MESSAGE_LENGTH));
+    }
+    parseInbound(payload) {
+        return parseInboundMessages(payload);
+    }
+    formatOutbound(context, response) {
+        const normalizedText = (0, formatting_1.normalizeOutboundText)(response.text);
+        const chunks = (0, formatting_1.chunkOutboundText)(normalizedText, this.maxMessageLength);
+        if (chunks.length === 0) {
+            return null;
+        }
+        const requests = chunks.map((chunk) => ({
+            method: "POST",
+            endpoint: `${this.apiBaseUrl}/${this.apiVersion}/${this.phoneNumberId}/messages`,
+            headers: {
+                authorization: `Bearer ${this.accessToken}`,
+                "content-type": "application/json"
+            },
+            body: {
+                messaging_product: "whatsapp",
+                recipient_type: "individual",
+                to: context.message.senderId,
+                type: "text",
+                text: {
+                    body: chunk
+                }
+            }
+        }));
+        return requests.length === 1 ? (requests[0] ?? null) : requests;
+    }
+}
+exports.WhatsAppAdapter = WhatsAppAdapter;

package/dist/gateway/auth-policy.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayAuthPolicy = void 0;
+function toSenderKey(message) {
+    return `${message.platform}:${message.senderId}`;
+}
+function parseAuthCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/auth")) {
+        return null;
+    }
+    const parts = trimmed.split(/\s+/);
+    if (parts[0] !== "/auth") {
+        return null;
+    }
+    return parts[1] ?? "";
+}
+class GatewayAuthPolicy {
+    allowedSenderIds;
+    passphrase;
+    authenticatedSenders = new Set();
+    constructor(options) {
+        this.allowedSenderIds =
+            options.allowedSenderIds && options.allowedSenderIds.length > 0
+                ? new Set(options.allowedSenderIds)
+                : null;
+        this.passphrase = options.passphrase?.trim() ? options.passphrase.trim() : null;
+    }
+    evaluate(message) {
+        if (this.allowedSenderIds && !this.allowedSenderIds.has(message.senderId)) {
+            return {
+                type: "unauthorized",
+                reason: "sender_not_allowed"
+            };
+        }
+        if (!this.passphrase) {
+            return {
+                type: "authorized"
+            };
+        }
+        const senderKey = toSenderKey(message);
+        if (this.authenticatedSenders.has(senderKey)) {
+            return {
+                type: "authorized"
+            };
+        }
+        const authAttempt = parseAuthCommand(message.text);
+        if (authAttempt === null) {
+            return {
+                type: "unauthorized",
+                reason: "passphrase_required"
+            };
+        }
+        if (authAttempt !== this.passphrase) {
+            return {
+                type: "unauthorized",
+                reason: "passphrase_invalid"
+            };
+        }
+        this.authenticatedSenders.add(senderKey);
+        return {
+            type: "authenticated"
+        };
+    }
+}
+exports.GatewayAuthPolicy = GatewayAuthPolicy;

package/dist/gateway/core.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayCore = void 0;
+const auth_policy_1 = require("#gateway/auth-policy");
+const message_router_1 = require("#gateway/message-router");
+const rate_limiter_1 = require("#gateway/rate-limiter");
+const session_manager_1 = require("#gateway/session-manager");
+class GatewayCore {
+    authPolicy;
+    unauthorizedMessage;
+    rateLimiter;
+    sessionManager;
+    handleMessageFn;
+    constructor(options) {
+        this.authPolicy = new auth_policy_1.GatewayAuthPolicy({
+            allowedSenderIds: options.allowedSenderIds,
+            passphrase: options.passphrase
+        });
+        this.unauthorizedMessage =
+            options.unauthorizedMessage ??
+                "Access denied. Authenticate with /auth <passphrase> or contact the administrator.";
+        this.rateLimiter =
+            options.rateLimiter ??
+                new rate_limiter_1.GatewayRateLimiter({
+                    maxMessages: 20,
+                    windowMs: 60_000
+                });
+        this.sessionManager = options.sessionManager ?? new session_manager_1.GatewaySessionManager();
+        this.handleMessageFn = options.handleMessage;
+    }
+    async dispatch(message) {
+        const normalizedMessage = (0, message_router_1.normalizeIncomingMessage)(message);
+        const validationError = (0, message_router_1.validateIncomingMessage)(normalizedMessage);
+        if (validationError) {
+            return {
+                status: "invalid",
+                reason: validationError
+            };
+        }
+        const authDecision = this.authPolicy.evaluate(normalizedMessage);
+        if (authDecision.type === "authenticated") {
+            return {
+                status: "authenticated",
+                response: {
+                    text: "Authentication successful. You can now send messages."
+                }
+            };
+        }
+        if (authDecision.type === "unauthorized") {
+            return {
+                status: "unauthorized",
+                reason: authDecision.reason,
+                response: {
+                    text: this.unauthorizedMessage
+                }
+            };
+        }
+        const rate = this.rateLimiter.check(normalizedMessage.senderId);
+        if (!rate.allowed) {
+            return {
+                status: "rate_limited",
+                reason: "rate_limit_exceeded",
+                retryAfterMs: rate.retryAfterMs
+            };
+        }
+        const session = this.sessionManager.getOrCreateSession(normalizedMessage);
+        const response = await this.handleMessageFn({
+            message: normalizedMessage,
+            session
+        });
+        return {
+            status: "ok",
+            sessionId: session.id,
+            response
+        };
+    }
+    listSessions() {
+        return this.sessionManager.listSessions();
+    }
+    pruneIdleSessions(maxIdleMs) {
+        return this.sessionManager.pruneIdleSessions(maxIdleMs);
+    }
+    pruneRateLimiterState() {
+        return this.rateLimiter.pruneStaleCounters();
+    }
+}
+exports.GatewayCore = GatewayCore;

package/dist/gateway/headless-conductor.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayHeadlessConductor = void 0;
+exports.createGatewayHeadlessMessageHandler = createGatewayHeadlessMessageHandler;
+const conductor_1 = require("#agent/conductor");
+const code_context_1 = require("#agent/context/code-context");
+const session_store_1 = require("#agent/context/session-store");
+const skills_1 = require("#agent/skills/skills");
+const tool_executor_1 = require("#agent/tools/tool-executor");
+const tool_safety_1 = require("#agent/tools/tool-safety");
+const llama_server_1 = require("#llm/llama-server");
+const llama_client_1 = require("#llm/llama-client");
+const token_counter_1 = require("#llm/token-counter");
+const vt_session_1 = require("#ui/input/vt-session");
+const UNSUPPORTED_BACKEND_RESPONSE = "Gateway headless mode currently supports backend 'llamacpp' only.";
+const AUTO_DENY_OUTPUT = "Action denied by gateway safety policy.";
+function composeChatRequestMessages(history, codeContextMessage) {
+    if (!codeContextMessage) {
+        return history;
+    }
+    return [{ role: "system", content: codeContextMessage }, ...history];
+}
+function buildSubagentScopeMessage(call) {
+    const lines = [
+        "Subagent scope:",
+        `Task: ${call.task}`,
+        call.context ? `Context: ${call.context}` : null,
+        call.allowedTools
+            ? `Allowed tools: ${call.allowedTools.length > 0 ? call.allowedTools.join(", ") : "(none)"}`
+            : "Allowed tools: all available tools",
+        "Stay focused on the delegated scope and return concise findings."
+    ].filter((line) => line !== null);
+    return lines.join("\n");
+}
+function assessToolCallRisk(call, workingZone) {
+    if (call.name === "run_command") {
+        const command = typeof call.arguments["command"] === "string" ? call.arguments["command"] : "";
+        const cwdArg = typeof call.arguments["cwd"] === "string" ? call.arguments["cwd"] : ".";
+        const resolvedCwd = (0, tool_safety_1.resolveToolPath)(cwdArg, workingZone);
+        return (0, tool_safety_1.assessCommandRisk)(command, resolvedCwd, workingZone);
+    }
+    const pathArg = typeof call.arguments["path"] === "string" ? call.arguments["path"] : ".";
+    return (0, tool_safety_1.assessPathRisk)(pathArg, workingZone);
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+const DEFAULT_DEPS = {
+    createLlamaClient: (config) => new llama_client_1.LlamaClient({
+        baseUrl: config.llamaBaseUrl,
+        model: config.model
+    }),
+    ensureReady: llama_server_1.ensureLlamaReady,
+    formatStartupFailure: llama_server_1.formatLlamaStartupFailure,
+    runConductor: conductor_1.runConductorTurn,
+    executeTool: tool_executor_1.executeToolCall,
+    executeSkill: skills_1.executeSkillCall,
+    createVtSession: () => new vt_session_1.VirtualTerminalSession(),
+    loadCodeContext: code_context_1.loadCodeContext,
+    toCodeContextSystemMessage: code_context_1.toCodeContextSystemMessage,
+    createSessionFile: session_store_1.createSessionFileFromHistory,
+    writeSessionFile: session_store_1.writeSessionFile,
+    estimateCompletionTokens: (text) => (0, token_counter_1.estimateConversationTokens)([{ content: text }]),
+    estimateHistoryTokens: (history) => (0, token_counter_1.estimateConversationTokens)(history)
+};
+class GatewayHeadlessConductor {
+    config;
+    gatewayBackend;
+    username;
+    workingDirectory;
+    maxRounds;
+    deps;
+    sessionStates = new Map();
+    llamaClient;
+    vtSession;
+    codeContextMessage = null;
+    constructor(options, deps = {}) {
+        this.config = options.config;
+        this.gatewayBackend = options.gatewayBackend ?? this.config.backend;
+        this.username = options.username ?? "Gateway User";
+        this.workingDirectory = options.workingDirectory ?? process.cwd();
+        this.maxRounds = options.maxRounds;
+        this.deps = { ...DEFAULT_DEPS, ...deps };
+        this.llamaClient = this.deps.createLlamaClient(this.config);
+        this.vtSession = this.deps.createVtSession();
+    }
+    async initialize() {
+        const loaded = await this.deps.loadCodeContext(this.workingDirectory);
+        if (!loaded) {
+            this.codeContextMessage = null;
+            return;
+        }
+        this.codeContextMessage = this.deps.toCodeContextSystemMessage(loaded);
+    }
+    async handleMessage(context) {
+        if (this.gatewayBackend !== "llamacpp") {
+            return {
+                text: `${UNSUPPORTED_BACKEND_RESPONSE} Configured backend: '${this.gatewayBackend}'.`
+            };
+        }
+        const state = this.getOrCreateSessionState(context);
+        state.history.push({ role: "user", content: context.message.text });
+        let latestAssistantText = "";
+        try {
+            await this.deps.runConductor({
+                history: state.history,
+                requestAssistant: async () => {
+                    const readiness = await this.deps.ensureReady(this.config);
+                    if (!readiness.ready) {
+                        throw new Error(readiness.failure
+                            ? this.deps.formatStartupFailure(readiness.failure, this.config)
+                            : "llama.cpp is unavailable.");
+                    }
+                    this.llamaClient.setModel(this.config.model);
+                    const requestMessages = composeChatRequestMessages(state.history, this.codeContextMessage);
+                    const result = await this.llamaClient.chat(requestMessages, this.config.model);
+                    return {
+                        text: result.text,
+                        rendered: false,
+                        totalTokens: result.usage?.totalTokens,
+                        completionTokens: result.usage?.completionTokens ?? this.deps.estimateCompletionTokens(result.text)
+                    };
+                },
+                executeToolCalls: async (toolCalls) => {
+                    const results = [];
+                    for (const call of toolCalls) {
+                        const risk = assessToolCallRisk(call, this.workingDirectory);
+                        if (risk.requiresConfirmation) {
+                            results.push({
+                                callId: call.id,
+                                tool: call.name,
+                                status: "denied",
+                                output: AUTO_DENY_OUTPUT
+                            });
+                            continue;
+                        }
+                        const result = await this.deps.executeTool(call, {
+                            workingDirectory: this.workingDirectory,
+                            vtSession: this.vtSession
+                        });
+                        results.push(result);
+                    }
+                    return results;
+                },
+                executeSkillCalls: async (skillCalls) => {
+                    const results = [];
+                    for (const call of skillCalls) {
+                        const result = await this.deps.executeSkill(call, {
+                            workingDirectory: this.workingDirectory,
+                            vtSession: this.vtSession
+                        });
+                        results.push(result);
+                    }
+                    return results;
+                },
+                executeSubagentCalls: async (subagentCalls) => {
+                    const results = [];
+                    for (const subagentCall of subagentCalls) {
+                        const scopedHistory = [
+                            { role: "system", content: buildSubagentScopeMessage(subagentCall) },
+                            { role: "user", content: subagentCall.task }
+                        ];
+                        const allowedTools = subagentCall.allowedTools !== undefined ? new Set(subagentCall.allowedTools) : null;
+                        try {
+                            const turn = await this.deps.runConductor({
+                                history: scopedHistory,
+                                requestAssistant: async () => {
+                                    const readiness = await this.deps.ensureReady(this.config);
+                                    if (!readiness.ready) {
+                                        throw new Error(readiness.failure
+                                            ? this.deps.formatStartupFailure(readiness.failure, this.config)
+                                            : "llama.cpp is unavailable.");
+                                    }
+                                    this.llamaClient.setModel(this.config.model);
+                                    const requestMessages = composeChatRequestMessages(scopedHistory, null);
+                                    const result = await this.llamaClient.chat(requestMessages, this.config.model);
+                                    return {
+                                        text: result.text,
+                                        rendered: false,
+                                        totalTokens: result.usage?.totalTokens,
+                                        completionTokens: result.usage?.completionTokens ??
+                                            this.deps.estimateCompletionTokens(result.text)
+                                    };
+                                },
+                                executeToolCalls: async (toolCalls) => {
+                                    const denied = [];
+                                    const permitted = [];
+                                    for (const call of toolCalls) {
+                                        if (allowedTools && !allowedTools.has(call.name)) {
+                                            denied.push({
+                                                callId: call.id,
+                                                tool: call.name,
+                                                status: "denied",
+                                                output: `Tool '${call.name}' is not allowed for subagent ${subagentCall.id}.`
+                                            });
+                                            continue;
+                                        }
+                                        const risk = assessToolCallRisk(call, this.workingDirectory);
+                                        if (risk.requiresConfirmation) {
+                                            denied.push({
+                                                callId: call.id,
+                                                tool: call.name,
+                                                status: "denied",
+                                                output: AUTO_DENY_OUTPUT
+                                            });
+                                            continue;
+                                        }
+                                        permitted.push(call);
+                                    }
+                                    const executed = [];
+                                    for (const call of permitted) {
+                                        const result = await this.deps.executeTool(call, {
+                                            workingDirectory: this.workingDirectory,
+                                            vtSession: this.vtSession
+                                        });
+                                        executed.push(result);
+                                    }
+                                    return [...denied, ...executed];
+                                },
+                                executeSkillCalls: async (skillCalls) => {
+                                    const skillResults = [];
+                                    for (const call of skillCalls) {
+                                        const result = await this.deps.executeSkill(call, {
+                                            workingDirectory: this.workingDirectory,
+                                            vtSession: this.vtSession
+                                        });
+                                        skillResults.push(result);
+                                    }
+                                    return skillResults;
+                                },
+                                onAssistantText: () => {
+                                    // Subagent responses are returned in metadata only.
+                                },
+                                onWarning: () => {
+                                    // Warnings are intentionally omitted from outbound gateway text.
+                                },
+                                estimateCompletionTokens: this.deps.estimateCompletionTokens,
+                                estimateHistoryTokens: this.deps.estimateHistoryTokens,
+                                computeTokensPerSecond: () => null,
+                                maxRounds: subagentCall.maxRounds ?? 4
+                            });
+                            const latest = [...scopedHistory]
+                                .reverse()
+                                .find((entry) => entry.role === "assistant")?.content;
+                            results.push({
+                                callId: subagentCall.id,
+                                status: turn.finished ? "ok" : "timeout",
+                                output: latest ?? "Subagent completed without assistant output.",
+                                metadata: {
+                                    rounds: turn.rounds
+                                }
+                            });
+                        }
+                        catch (error) {
+                            results.push({
+                                callId: subagentCall.id,
+                                status: "error",
+                                output: `Subagent failed: ${toErrorMessage(error)}`
+                            });
+                        }
+                    }
+                    return results;
+                },
+                onAssistantText: (assistantText) => {
+                    latestAssistantText = assistantText;
+                },
+                onWarning: () => {
+                    // Warnings are intentionally omitted from outbound gateway text.
+                },
+                estimateCompletionTokens: this.deps.estimateCompletionTokens,
+                estimateHistoryTokens: this.deps.estimateHistoryTokens,
+                computeTokensPerSecond: () => null,
+                maxRounds: this.maxRounds
+            });
+        }
+        catch (error) {
+            const message = `Request failed: ${toErrorMessage(error)}`;
+            state.history.push({ role: "assistant", content: message });
+            await this.persistSession(state);
+            return { text: message };
+        }
+        const finalText = latestAssistantText.trim().length > 0 ? latestAssistantText : "(no response)";
+        await this.persistSession(state);
+        return { text: finalText };
+    }
+    dispose() {
+        this.vtSession.dispose();
+        this.sessionStates.clear();
+    }
+    getOrCreateSessionState(context) {
+        const key = `${context.session.id}:${context.session.createdAt.toISOString()}`;
+        const existing = this.sessionStates.get(key);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            history: [],
+            sessionFilePath: null
+        };
+        this.sessionStates.set(key, created);
+        return created;
+    }
+    async persistSession(state) {
+        if (state.history.length === 0) {
+            return;
+        }
+        if (!state.sessionFilePath) {
+            const created = await this.deps.createSessionFile(state.history);
+            state.sessionFilePath = created.path;
+        }
+        await this.deps.writeSessionFile({
+            path: state.sessionFilePath,
+            username: this.username,
+            history: state.history
+        });
+    }
+}
+exports.GatewayHeadlessConductor = GatewayHeadlessConductor;
+async function createGatewayHeadlessMessageHandler(options, deps = {}) {
+    const runtime = new GatewayHeadlessConductor(options, deps);
+    await runtime.initialize();
+    return {
+        handleMessage: async (context) => await runtime.handleMessage(context),
+        dispose: () => {
+            runtime.dispose();
+        }
+    };
+}

package/dist/gateway/message-router.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeIncomingMessage = normalizeIncomingMessage;
+exports.validateIncomingMessage = validateIncomingMessage;
+const MAX_TEXT_LENGTH = 4000;
+function normalizeIncomingMessage(message) {
+    return {
+        ...message,
+        senderId: message.senderId.trim(),
+        channelId: message.channelId?.trim(),
+        text: message.text.trim().slice(0, MAX_TEXT_LENGTH),
+        timestamp: message.timestamp ?? new Date()
+    };
+}
+function validateIncomingMessage(message) {
+    if (message.senderId.trim().length === 0) {
+        return "sender_id_required";
+    }
+    if (message.text.trim().length === 0) {
+        return "message_text_required";
+    }
+    return null;
+}

package/dist/gateway/rate-limiter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayRateLimiter = void 0;
+class GatewayRateLimiter {
+    maxMessages;
+    windowMs;
+    counters = new Map();
+    now;
+    constructor(options, now = () => new Date()) {
+        this.maxMessages = Math.max(1, Math.trunc(options.maxMessages));
+        this.windowMs = Math.max(1000, Math.trunc(options.windowMs));
+        this.now = now;
+    }
+    check(senderId) {
+        const now = this.now().valueOf();
+        const existing = this.counters.get(senderId);
+        const active = existing && now - existing.startedAt < this.windowMs ? existing : { count: 0, startedAt: now };
+        active.count += 1;
+        this.counters.set(senderId, active);
+        const resetAt = new Date(active.startedAt + this.windowMs);
+        if (active.count <= this.maxMessages) {
+            return {
+                allowed: true,
+                remaining: this.maxMessages - active.count,
+                retryAfterMs: 0,
+                resetAt
+            };
+        }
+        return {
+            allowed: false,
+            remaining: 0,
+            retryAfterMs: Math.max(1, active.startedAt + this.windowMs - now),
+            resetAt
+        };
+    }
+    pruneStaleCounters() {
+        const now = this.now().valueOf();
+        let removed = 0;
+        for (const [senderId, window] of this.counters) {
+            if (now - window.startedAt >= this.windowMs) {
+                this.counters.delete(senderId);
+                removed += 1;
+            }
+        }
+        return removed;
+    }
+}
+exports.GatewayRateLimiter = GatewayRateLimiter;