@shepai/cli 1.180.0-pr548.764147 → 1.181.0-pr512.ba01d33

package/dist/packages/core/src/infrastructure/services/messaging/chat-relay.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Messaging Chat Relay
+ *
+ * Bridges messaging app chat ↔ Shep interactive agent sessions.
+ * When a user enters "chat mode" via /chat <feature_id>, their messages
+ * are relayed to the agent and agent responses are batched and sent back
+ * through the tunnel.
+ *
+ * Output batching: agent streaming output is buffered and flushed every
+ * N milliseconds (default 3s) to avoid flooding messaging platforms.
+ * Only one active relay per user at a time.
+ */
+import type { IMessageSender } from '../../../application/ports/output/services/message-sender.interface.js';
+/**
+ * Manages the bidirectional chat relay between messaging apps
+ * and Shep interactive agent sessions.
+ */
+export declare class MessagingChatRelay {
+    private readonly sender;
+    private readonly bufferIntervalMs;
+    private activeRelay;
+    private buffer;
+    private bufferTimer;
+    constructor(sender: IMessageSender, bufferIntervalMs?: number);
+    /** Start a chat relay for a specific feature */
+    startRelay(featureId: string, chatId: string, platform: string, worktreePath?: string, unsubscribe?: () => void): string;
+    /** Get the worktree path of the active relay, if any. */
+    getActiveWorktreePath(): string | null;
+    /** End the active chat relay */
+    endRelay(): string;
+    /** Check if there is an active relay */
+    hasActiveRelay(): boolean;
+    /** Get the active relay's feature ID */
+    getActiveFeatureId(): string | null;
+    /**
+     * Buffer an agent response chunk and schedule a flush.
+     * Called when the agent produces output during a chat relay.
+     */
+    bufferAgentOutput(delta: string): void;
+    /** Flush any buffered output immediately (e.g., on stream completion) */
+    flushBuffer(): void;
+    /** Stop the relay and clean up all resources */
+    stop(): void;
+}
+//# sourceMappingURL=chat-relay.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/chat-relay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-relay.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/chat-relay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wEAAwE,CAAC;AAa7G;;;GAGG;AACH,qBAAa,kBAAkB;IAM3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IANnC,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,WAAW,CAA8C;gBAG9C,MAAM,EAAE,cAAc,EACtB,gBAAgB,GAAE,MAAmC;IAGxE,gDAAgD;IAChD,UAAU,CACR,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,YAAY,SAAK,EACjB,WAAW,CAAC,EAAE,MAAM,IAAI,GACvB,MAAM;IAWT,yDAAyD;IACzD,qBAAqB,IAAI,MAAM,GAAG,IAAI;IAItC,gCAAgC;IAChC,QAAQ,IAAI,MAAM;IAYlB,wCAAwC;IACxC,cAAc,IAAI,OAAO;IAIzB,wCAAwC;IACxC,kBAAkB,IAAI,MAAM,GAAG,IAAI;IAInC;;;OAGG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAatC,yEAAyE;IACzE,WAAW,IAAI,IAAI;IAkBnB,gDAAgD;IAChD,IAAI,IAAI,IAAI;CAKb"}

package/dist/packages/core/src/infrastructure/services/messaging/chat-relay.js

@@ -0,0 +1,100 @@
+/**
+ * Messaging Chat Relay
+ *
+ * Bridges messaging app chat ↔ Shep interactive agent sessions.
+ * When a user enters "chat mode" via /chat <feature_id>, their messages
+ * are relayed to the agent and agent responses are batched and sent back
+ * through the tunnel.
+ *
+ * Output batching: agent streaming output is buffered and flushed every
+ * N milliseconds (default 3s) to avoid flooding messaging platforms.
+ * Only one active relay per user at a time.
+ */
+import { sanitizeForMessaging } from './content-sanitizer.js';
+const DEFAULT_BUFFER_INTERVAL_MS = 3_000;
+/**
+ * Manages the bidirectional chat relay between messaging apps
+ * and Shep interactive agent sessions.
+ */
+export class MessagingChatRelay {
+    sender;
+    bufferIntervalMs;
+    activeRelay = null;
+    buffer = '';
+    bufferTimer = null;
+    constructor(sender, bufferIntervalMs = DEFAULT_BUFFER_INTERVAL_MS) {
+        this.sender = sender;
+        this.bufferIntervalMs = bufferIntervalMs;
+    }
+    /** Start a chat relay for a specific feature */
+    startRelay(featureId, chatId, platform, worktreePath = '', unsubscribe) {
+        // Tear down any previous relay (including its subscription).
+        if (this.activeRelay) {
+            this.flushBuffer();
+            this.activeRelay.unsubscribe?.();
+        }
+        this.activeRelay = { featureId, chatId, platform, worktreePath, unsubscribe };
+        return `Chat relay started for feature #${featureId}. Send messages here to talk to the agent. /end to stop.`;
+    }
+    /** Get the worktree path of the active relay, if any. */
+    getActiveWorktreePath() {
+        return this.activeRelay?.worktreePath ?? null;
+    }
+    /** End the active chat relay */
+    endRelay() {
+        if (!this.activeRelay) {
+            return 'No active chat relay.';
+        }
+        this.flushBuffer();
+        const fid = this.activeRelay.featureId;
+        this.activeRelay.unsubscribe?.();
+        this.activeRelay = null;
+        return `Chat relay ended for feature #${fid}.`;
+    }
+    /** Check if there is an active relay */
+    hasActiveRelay() {
+        return this.activeRelay !== null;
+    }
+    /** Get the active relay's feature ID */
+    getActiveFeatureId() {
+        return this.activeRelay?.featureId ?? null;
+    }
+    /**
+     * Buffer an agent response chunk and schedule a flush.
+     * Called when the agent produces output during a chat relay.
+     */
+    bufferAgentOutput(delta) {
+        if (!this.activeRelay)
+            return;
+        this.buffer += delta;
+        if (!this.bufferTimer) {
+            this.bufferTimer = setTimeout(() => {
+                this.flushBuffer();
+            }, this.bufferIntervalMs);
+            this.bufferTimer.unref();
+        }
+    }
+    /** Flush any buffered output immediately (e.g., on stream completion) */
+    flushBuffer() {
+        if (this.buffer && this.activeRelay) {
+            const notification = {
+                event: 'chat.response',
+                featureId: this.activeRelay.featureId,
+                title: '',
+                message: sanitizeForMessaging(this.buffer),
+            };
+            void this.sender.send(notification);
+            this.buffer = '';
+        }
+        if (this.bufferTimer) {
+            clearTimeout(this.bufferTimer);
+            this.bufferTimer = null;
+        }
+    }
+    /** Stop the relay and clean up all resources */
+    stop() {
+        this.flushBuffer();
+        this.activeRelay?.unsubscribe?.();
+        this.activeRelay = null;
+    }
+}

package/dist/packages/core/src/infrastructure/services/messaging/command-executor.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Messaging Command Executor
+ *
+ * Maps inbound MessagingCommand payloads from the Gateway tunnel
+ * to existing Shep use case invocations. This is the bridge between
+ * external messaging commands and the application layer.
+ *
+ * All commands are mapped to existing use cases — no new business logic
+ * is introduced here. The executor is a thin translation layer.
+ *
+ * Feature ID resolution: messaging commands use short IDs (first 8 chars
+ * of the UUID). The ShowFeatureUseCase and ResumeFeatureUseCase support
+ * prefix matching via findByIdPrefix. For approve/reject/stop, we resolve
+ * the feature first, then use its agentRunId.
+ */
+import type { MessagingCommand } from '../../../domain/generated/output.js';
+import type { IFeatureRepository } from '../../../application/ports/output/repositories/feature-repository.interface.js';
+import type { ListFeaturesUseCase } from '../../../application/use-cases/features/list-features.use-case.js';
+import type { ShowFeatureUseCase } from '../../../application/use-cases/features/show-feature.use-case.js';
+import type { CreateFeatureUseCase } from '../../../application/use-cases/features/create/create-feature.use-case.js';
+import type { ApproveAgentRunUseCase } from '../../../application/use-cases/agents/approve-agent-run.use-case.js';
+import type { RejectAgentRunUseCase } from '../../../application/use-cases/agents/reject-agent-run.use-case.js';
+import type { StopAgentRunUseCase } from '../../../application/use-cases/agents/stop-agent-run.use-case.js';
+import type { ResumeFeatureUseCase } from '../../../application/use-cases/features/resume-feature.use-case.js';
+import type { ListRepositoriesUseCase } from '../../../application/use-cases/repositories/list-repositories.use-case.js';
+/**
+ * Execute messaging commands by delegating to existing use cases.
+ */
+export declare class MessagingCommandExecutor {
+    private readonly featureRepo;
+    private readonly createFeature;
+    private readonly approveAgentRun;
+    private readonly rejectAgentRun;
+    private readonly stopAgentRun;
+    private readonly resumeFeature;
+    private readonly listFeatures;
+    private readonly showFeature;
+    private readonly listRepositories;
+    constructor(featureRepo: IFeatureRepository, createFeature: CreateFeatureUseCase, approveAgentRun: ApproveAgentRunUseCase, rejectAgentRun: RejectAgentRunUseCase, stopAgentRun: StopAgentRunUseCase, resumeFeature: ResumeFeatureUseCase, listFeatures: ListFeaturesUseCase, showFeature: ShowFeatureUseCase, listRepositories: ListRepositoriesUseCase);
+    /**
+     * Execute a messaging command and return a human-readable response.
+     */
+    execute(cmd: MessagingCommand): Promise<string>;
+    private handleNew;
+    private handleApprove;
+    private handleReject;
+    private handleStop;
+    private handleResume;
+    private handleStatus;
+    /** Resolve a feature by exact ID or prefix match */
+    private resolveFeature;
+}
+//# sourceMappingURL=command-executor.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/command-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-executor.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/command-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAW,MAAM,qCAAqC,CAAC;AACrF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gFAAgF,CAAC;AACzH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mEAAmE,CAAC;AAC7G,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kEAAkE,CAAC;AAC3G,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2EAA2E,CAAC;AACtH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qEAAqE,CAAC;AAClH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oEAAoE,CAAC;AAChH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kEAAkE,CAAC;AAC5G,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oEAAoE,CAAC;AAC/G,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2EAA2E,CAAC;AAkBzH;;GAEG;AACH,qBAAa,wBAAwB;IAEjC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBARhB,WAAW,EAAE,kBAAkB,EAC/B,aAAa,EAAE,oBAAoB,EACnC,eAAe,EAAE,sBAAsB,EACvC,cAAc,EAAE,qBAAqB,EACrC,YAAY,EAAE,mBAAmB,EACjC,aAAa,EAAE,oBAAoB,EACnC,YAAY,EAAE,mBAAmB,EACjC,WAAW,EAAE,kBAAkB,EAC/B,gBAAgB,EAAE,uBAAuB;IAG5D;;OAEG;IACG,OAAO,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC;YAqBvC,SAAS;YA0BT,aAAa;YAwBb,YAAY;YA2BZ,UAAU;YAwBV,YAAY;YAaZ,YAAY;IAkB1B,oDAAoD;YACtC,cAAc;CAM7B"}

package/dist/packages/core/src/infrastructure/services/messaging/command-executor.js

@@ -0,0 +1,200 @@
+/**
+ * Messaging Command Executor
+ *
+ * Maps inbound MessagingCommand payloads from the Gateway tunnel
+ * to existing Shep use case invocations. This is the bridge between
+ * external messaging commands and the application layer.
+ *
+ * All commands are mapped to existing use cases — no new business logic
+ * is introduced here. The executor is a thin translation layer.
+ *
+ * Feature ID resolution: messaging commands use short IDs (first 8 chars
+ * of the UUID). The ShowFeatureUseCase and ResumeFeatureUseCase support
+ * prefix matching via findByIdPrefix. For approve/reject/stop, we resolve
+ * the feature first, then use its agentRunId.
+ */
+const HELP_TEXT = `Available commands:
+/new <description> — Create a new feature
+/approve <id> — Approve gate on feature
+/reject <id> [feedback] — Reject with feedback
+/stop <id> — Stop agent on feature
+/resume <id> — Resume paused feature
+/status — List all active features
+/status <id> — Show detail for feature
+/help — Show this help text`;
+/** Format a feature for display in messaging */
+function formatFeature(f) {
+    const shortId = f.id.slice(0, 8);
+    return `#${shortId} "${f.name}" — ${f.lifecycle}`;
+}
+/**
+ * Execute messaging commands by delegating to existing use cases.
+ */
+export class MessagingCommandExecutor {
+    featureRepo;
+    createFeature;
+    approveAgentRun;
+    rejectAgentRun;
+    stopAgentRun;
+    resumeFeature;
+    listFeatures;
+    showFeature;
+    listRepositories;
+    constructor(featureRepo, createFeature, approveAgentRun, rejectAgentRun, stopAgentRun, resumeFeature, listFeatures, showFeature, listRepositories) {
+        this.featureRepo = featureRepo;
+        this.createFeature = createFeature;
+        this.approveAgentRun = approveAgentRun;
+        this.rejectAgentRun = rejectAgentRun;
+        this.stopAgentRun = stopAgentRun;
+        this.resumeFeature = resumeFeature;
+        this.listFeatures = listFeatures;
+        this.showFeature = showFeature;
+        this.listRepositories = listRepositories;
+    }
+    /**
+     * Execute a messaging command and return a human-readable response.
+     */
+    async execute(cmd) {
+        switch (cmd.command) {
+            case 'new':
+                return this.handleNew(cmd);
+            case 'approve':
+                return this.handleApprove(cmd);
+            case 'reject':
+                return this.handleReject(cmd);
+            case 'stop':
+                return this.handleStop(cmd);
+            case 'resume':
+                return this.handleResume(cmd);
+            case 'status':
+                return this.handleStatus(cmd);
+            case 'help':
+                return HELP_TEXT;
+            default:
+                return `Unknown command: ${cmd.command}. Send /help for available commands.`;
+        }
+    }
+    async handleNew(cmd) {
+        if (!cmd.args) {
+            return 'Usage: /new <feature description>';
+        }
+        try {
+            // Resolve a default repository path from the first tracked repository
+            const repos = await this.listRepositories.execute();
+            if (repos.length === 0) {
+                return 'No repositories configured. Add a repository in the Shep UI first.';
+            }
+            const result = await this.createFeature.execute({
+                userInput: cmd.args,
+                repositoryPath: repos[0].path,
+                fast: true,
+                push: true,
+                openPr: true,
+            });
+            const shortId = result.feature.id.slice(0, 8);
+            return `Started: "${cmd.args}" — feature #${shortId}`;
+        }
+        catch (error) {
+            return `Failed to create feature: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleApprove(cmd) {
+        if (!cmd.featureId) {
+            return 'Usage: /approve <feature_id>';
+        }
+        try {
+            const feature = await this.resolveFeature(cmd.featureId);
+            if (!feature) {
+                return `Feature #${cmd.featureId} not found`;
+            }
+            if (!feature.agentRunId) {
+                return `Feature #${cmd.featureId} has no active agent run`;
+            }
+            const result = await this.approveAgentRun.execute(feature.agentRunId);
+            if (!result.approved) {
+                return `Cannot approve: ${result.reason}`;
+            }
+            return `Approved feature #${cmd.featureId}`;
+        }
+        catch (error) {
+            return `Failed to approve: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleReject(cmd) {
+        if (!cmd.featureId) {
+            return 'Usage: /reject <feature_id> [feedback]';
+        }
+        try {
+            const feature = await this.resolveFeature(cmd.featureId);
+            if (!feature) {
+                return `Feature #${cmd.featureId} not found`;
+            }
+            if (!feature.agentRunId) {
+                return `Feature #${cmd.featureId} has no active agent run`;
+            }
+            const result = await this.rejectAgentRun.execute(feature.agentRunId, cmd.args ?? 'Rejected via messaging');
+            if (!result.rejected) {
+                return `Cannot reject: ${result.reason}`;
+            }
+            return `Rejected feature #${cmd.featureId}${cmd.args ? ' with feedback' : ''}`;
+        }
+        catch (error) {
+            return `Failed to reject: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleStop(cmd) {
+        if (!cmd.featureId) {
+            return 'Usage: /stop <feature_id>';
+        }
+        try {
+            const feature = await this.resolveFeature(cmd.featureId);
+            if (!feature) {
+                return `Feature #${cmd.featureId} not found`;
+            }
+            if (!feature.agentRunId) {
+                return `Feature #${cmd.featureId} has no active agent run`;
+            }
+            const result = await this.stopAgentRun.execute(feature.agentRunId);
+            if (!result.stopped) {
+                return `Cannot stop: ${result.reason}`;
+            }
+            return `Stopped agent on feature #${cmd.featureId}`;
+        }
+        catch (error) {
+            return `Failed to stop: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleResume(cmd) {
+        if (!cmd.featureId) {
+            return 'Usage: /resume <feature_id>';
+        }
+        try {
+            await this.resumeFeature.execute(cmd.featureId);
+            return `Resumed feature #${cmd.featureId}`;
+        }
+        catch (error) {
+            return `Failed to resume: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async handleStatus(cmd) {
+        try {
+            if (cmd.featureId) {
+                const feature = await this.showFeature.execute(cmd.featureId);
+                return formatFeature(feature);
+            }
+            const features = await this.listFeatures.execute();
+            if (features.length === 0) {
+                return 'No active features.';
+            }
+            return features.map(formatFeature).join('\n');
+        }
+        catch (error) {
+            return `Failed to get status: ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    /** Resolve a feature by exact ID or prefix match */
+    async resolveFeature(featureId) {
+        return ((await this.featureRepo.findById(featureId)) ??
+            (await this.featureRepo.findByIdPrefix(featureId)));
+    }
+}

package/dist/packages/core/src/infrastructure/services/messaging/content-sanitizer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Content Sanitizer
+ *
+ * Sanitizes outbound messages to ensure no sensitive content
+ * (file paths, environment variables, code blocks, secrets)
+ * is transmitted through third-party messaging platforms.
+ *
+ * Security requirement FR-6: no source code, diffs, or file
+ * contents transmitted through messaging platforms.
+ */
+/**
+ * Strip sensitive content from a message before sending to a messaging platform.
+ *
+ * Removes:
+ * - Absolute file paths
+ * - Environment variable assignments
+ * - Code blocks (fenced with backticks)
+ * - Potential secret patterns (API keys, tokens)
+ *
+ * Truncates to messaging-safe length.
+ */
+export declare function sanitizeForMessaging(text: string): string;
+//# sourceMappingURL=content-sanitizer.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/content-sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-sanitizer.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/content-sanitizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAsBzD"}

package/dist/packages/core/src/infrastructure/services/messaging/content-sanitizer.js

@@ -0,0 +1,39 @@
+/**
+ * Content Sanitizer
+ *
+ * Sanitizes outbound messages to ensure no sensitive content
+ * (file paths, environment variables, code blocks, secrets)
+ * is transmitted through third-party messaging platforms.
+ *
+ * Security requirement FR-6: no source code, diffs, or file
+ * contents transmitted through messaging platforms.
+ */
+const MAX_MESSAGE_LENGTH = 4000;
+/**
+ * Strip sensitive content from a message before sending to a messaging platform.
+ *
+ * Removes:
+ * - Absolute file paths
+ * - Environment variable assignments
+ * - Code blocks (fenced with backticks)
+ * - Potential secret patterns (API keys, tokens)
+ *
+ * Truncates to messaging-safe length.
+ */
+export function sanitizeForMessaging(text) {
+    let sanitized = text;
+    // Strip absolute file paths (Unix and Windows)
+    sanitized = sanitized.replace(/(?:\/[\w.\-/]+){2,}/g, '[path]');
+    sanitized = sanitized.replace(/[A-Z]:\\[\w.\-\\]+/g, '[path]');
+    // Strip env-var-like patterns (KEY=value)
+    sanitized = sanitized.replace(/[A-Z_]{3,}=\S+/g, '[env]');
+    // Strip fenced code blocks
+    sanitized = sanitized.replace(/```[\s\S]*?```/g, '[code block]');
+    // Strip inline code that looks like file content
+    sanitized = sanitized.replace(/`[^`]{100,}`/g, '[code]');
+    // Truncate to messaging-safe length
+    if (sanitized.length > MAX_MESSAGE_LENGTH) {
+        sanitized = `${sanitized.slice(0, MAX_MESSAGE_LENGTH - 3)}...`;
+    }
+    return sanitized;
+}

package/dist/packages/core/src/infrastructure/services/messaging/http-gateway.client.d.ts

@@ -0,0 +1,19 @@
+/**
+ * HTTP Gateway Client
+ *
+ * Concrete implementation of IGatewayClient that speaks the Commands.com
+ * Gateway OpenAPI (see https://github.com/Commands-com/gateway/blob/main/docs/openapi.yaml).
+ *
+ * This adapter is infrastructure — it knows about HTTP verbs, status codes,
+ * and the gateway's wire format. Callers receive domain objects only.
+ */
+import type { IGatewayClient, FetchTokenInput, GatewayOAuthToken, CreateIntegrationRouteInput, GatewayIntegrationRoute } from '../../../application/ports/output/services/gateway-client.interface.js';
+type FetchFn = typeof fetch;
+export declare class HttpGatewayClient implements IGatewayClient {
+    private readonly fetchImpl;
+    constructor(fetchImpl?: FetchFn);
+    fetchAccessToken(input: FetchTokenInput): Promise<GatewayOAuthToken>;
+    createIntegrationRoute(gatewayUrl: string, accessToken: string, input: CreateIntegrationRouteInput): Promise<GatewayIntegrationRoute>;
+}
+export {};
+//# sourceMappingURL=http-gateway.client.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/http-gateway.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-gateway.client.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/http-gateway.client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,2BAA2B,EAC3B,uBAAuB,EACxB,MAAM,wEAAwE,CAAC;AAEhF,KAAK,OAAO,GAAG,OAAO,KAAK,CAAC;AAqB5B,qBACa,iBAAkB,YAAW,cAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,GAAE,OAAe;IAEjD,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA+CpE,sBAAsB,CAC1B,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,uBAAuB,CAAC;CAsDpC"}

package/dist/packages/core/src/infrastructure/services/messaging/http-gateway.client.js

@@ -0,0 +1,124 @@
+/**
+ * HTTP Gateway Client
+ *
+ * Concrete implementation of IGatewayClient that speaks the Commands.com
+ * Gateway OpenAPI (see https://github.com/Commands-com/gateway/blob/main/docs/openapi.yaml).
+ *
+ * This adapter is infrastructure — it knows about HTTP verbs, status codes,
+ * and the gateway's wire format. Callers receive domain objects only.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { injectable } from 'tsyringe';
+function stripTrailingSlash(url) {
+    return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+async function readErrorBody(response) {
+    try {
+        const contentType = response.headers.get('content-type') ?? '';
+        if (contentType.includes('application/json')) {
+            const json = (await response.json());
+            const err = typeof json.error === 'string' ? json.error : undefined;
+            const msg = typeof json.message === 'string' ? json.message : undefined;
+            return err ?? msg ?? JSON.stringify(json);
+        }
+        return await response.text();
+    }
+    catch {
+        return '';
+    }
+}
+let HttpGatewayClient = class HttpGatewayClient {
+    fetchImpl;
+    constructor(fetchImpl = fetch) {
+        this.fetchImpl = fetchImpl;
+    }
+    async fetchAccessToken(input) {
+        const base = stripTrailingSlash(input.gatewayUrl);
+        const url = `${base}/oauth/token`;
+        const params = new URLSearchParams();
+        params.set('grant_type', 'client_credentials');
+        params.set('client_id', input.clientId);
+        if (input.clientSecret) {
+            params.set('client_secret', input.clientSecret);
+        }
+        if (input.scope) {
+            params.set('scope', input.scope);
+        }
+        const response = await this.fetchImpl(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/x-www-form-urlencoded' },
+            body: params.toString(),
+        });
+        if (!response.ok) {
+            const detail = await readErrorBody(response);
+            throw new Error(`Gateway /oauth/token failed with ${response.status}${detail ? `: ${detail}` : ''}`);
+        }
+        const body = (await response.json());
+        if (!body.access_token) {
+            throw new Error('Gateway /oauth/token response missing access_token');
+        }
+        const expiresInMs = Math.max(0, (body.expires_in ?? 0) * 1000);
+        return {
+            accessToken: body.access_token,
+            tokenType: body.token_type ?? 'Bearer',
+            expiresAt: Date.now() + expiresInMs,
+            refreshToken: body.refresh_token,
+        };
+    }
+    async createIntegrationRoute(gatewayUrl, accessToken, input) {
+        const base = stripTrailingSlash(gatewayUrl);
+        const url = `${base}/gateway/v1/integrations/routes`;
+        const payload = {
+            device_id: input.deviceId,
+            interface_type: input.interfaceType,
+            token_auth_mode: 'path',
+        };
+        if (input.routeToken !== undefined)
+            payload.route_token = input.routeToken;
+        if (input.tokenMaxAgeDays !== undefined)
+            payload.token_max_age_days = input.tokenMaxAgeDays;
+        if (input.maxBodyBytes !== undefined)
+            payload.max_body_bytes = input.maxBodyBytes;
+        if (input.deadlineMs !== undefined)
+            payload.deadline_ms = input.deadlineMs;
+        const response = await this.fetchImpl(url, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${accessToken}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            const detail = await readErrorBody(response);
+            throw new Error(`Gateway /gateway/v1/integrations/routes failed with ${response.status}${detail ? `: ${detail}` : ''}`);
+        }
+        const body = (await response.json());
+        const routeId = body.route?.route_id;
+        const publicUrl = body.public_url;
+        const routeToken = body.route_token;
+        if (!routeId || !publicUrl || !routeToken) {
+            throw new Error('Gateway route response missing route_id, public_url, or route_token');
+        }
+        return {
+            routeId,
+            routeToken,
+            publicUrl,
+            deviceId: body.route?.device_id ?? input.deviceId,
+            interfaceType: body.route?.interface_type ?? input.interfaceType,
+        };
+    }
+};
+HttpGatewayClient = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Function])
+], HttpGatewayClient);
+export { HttpGatewayClient };

package/dist/packages/core/src/infrastructure/services/messaging/http-telegram.client.d.ts

@@ -0,0 +1,18 @@
+/**
+ * HTTP Telegram Client
+ *
+ * Thin adapter over the Telegram Bot API for sending messages. Only
+ * implements the surface needed for the remote control integration —
+ * sendMessage, with optional parse_mode.
+ *
+ * Reference: https://core.telegram.org/bots/api#sendmessage
+ */
+import type { ITelegramClient, SendTelegramMessageInput } from '../../../application/ports/output/services/telegram-client.interface.js';
+type FetchFn = typeof fetch;
+export declare class HttpTelegramClient implements ITelegramClient {
+    private readonly fetchImpl;
+    constructor(fetchImpl?: FetchFn);
+    sendMessage(input: SendTelegramMessageInput): Promise<void>;
+}
+export {};
+//# sourceMappingURL=http-telegram.client.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/http-telegram.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-telegram.client.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/http-telegram.client.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,wBAAwB,EACzB,MAAM,yEAAyE,CAAC;AAEjF,KAAK,OAAO,GAAG,OAAO,KAAK,CAAC;AAI5B,qBACa,kBAAmB,YAAW,eAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,GAAE,OAAe;IAEjD,WAAW,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC;CA8BlE"}