@shakudo/opencode-mattermost-control 0.3.45

package/.opencode/plugin/mattermost-control/tools/monitor.ts

@@ -0,0 +1,183 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin";
+import { PluginState } from "../state.js";
+import { MattermostClient } from "../../../../src/clients/mattermost-client.js";
+import { MonitorService, type MonitoredSession } from "../../../../src/monitor-service.js";
+import { loadConfig } from "../../../../src/config.js";
+import { log } from "../../../../src/logger.js";
+
+export interface MonitorContext {
+  client: any;
+  directory: string;
+  projectName: string;
+}
+
+export function createMonitorTool(ctx: MonitorContext): ToolDefinition {
+  return tool({
+    description: "Monitor an OpenCode session for events (permission requests, idle, questions). Sends DM alerts when the session needs attention.",
+    args: {
+      sessionId: tool.schema.string().optional().describe("Session ID to monitor. Defaults to current session if not specified."),
+      targetUser: tool.schema.string().optional().describe("Mattermost username to notify (required if not connected to Mattermost)."),
+      persistent: tool.schema.boolean().optional().describe("Keep monitoring after each alert (default: true). Set to false for one-time alerts."),
+    },
+    async execute(args) {
+      const config = loadConfig();
+
+      if (!config.mattermost.token) {
+        return "MATTERMOST_TOKEN environment variable is required.";
+      }
+
+      if (config.mattermost.baseUrl.includes("your-mattermost-instance.example.com")) {
+        return "MATTERMOST_URL environment variable is required.";
+      }
+
+      let targetSessionId = args.sessionId;
+      let targetProjectName = ctx.projectName;
+      let targetDirectory = ctx.directory;
+      let targetSessionTitle: string | undefined;
+
+      if (!targetSessionId) {
+        targetSessionId = await resolveCurrentSession(ctx.client, ctx.directory);
+      } else if (PluginState.openCodeSessionRegistry) {
+        const session = PluginState.openCodeSessionRegistry.get(targetSessionId);
+        if (session) {
+          targetSessionId = session.id;
+          targetProjectName = session.projectName;
+          targetDirectory = session.directory;
+        }
+      }
+
+      if (!targetSessionId) {
+        return "No session ID provided and could not determine current session.";
+      }
+
+      try {
+        const sessionDetails = await ctx.client.session.get({ path: { id: targetSessionId } });
+        if (sessionDetails.data) {
+          targetSessionTitle = sessionDetails.data.title;
+        }
+      } catch (e) {
+        log.debug(`[Monitor] Could not fetch session details: ${e}`);
+      }
+
+      if (MonitorService.isMonitored(targetSessionId)) {
+        return `Session ${targetSessionId.substring(0, 8)} is already being monitored.`;
+      }
+
+      let mattermostUserId: string;
+      let mattermostUsername: string;
+
+      if (args.targetUser) {
+        try {
+          const tempClient = new MattermostClient(config.mattermost);
+          const user = await tempClient.getUserByUsername(args.targetUser.replace(/^@/, ""));
+          mattermostUserId = user.id;
+          mattermostUsername = user.username;
+        } catch (e) {
+          return `Could not find Mattermost user: ${args.targetUser}`;
+        }
+      } else if (PluginState.botUser) {
+        mattermostUserId = PluginState.botUser.id;
+        mattermostUsername = PluginState.botUser.username;
+      } else {
+        return "targetUser is required when not connected to Mattermost. Specify the Mattermost username to notify.";
+      }
+
+      const isPersistent = args.persistent !== false;
+      
+      const monitoredSession: MonitoredSession = {
+        sessionId: targetSessionId,
+        shortId: targetSessionId.substring(0, 8),
+        mattermostUserId,
+        mattermostUsername,
+        projectName: targetProjectName,
+        sessionTitle: targetSessionTitle,
+        directory: targetDirectory,
+        registeredAt: new Date(),
+        persistent: isPersistent,
+      };
+
+      MonitorService.register(monitoredSession);
+
+      const modeText = isPersistent 
+        ? "_Persistent monitoring enabled. Use `mattermost_unmonitor` to stop._"
+        : "_One-time alert. After notification, monitoring stops._";
+      
+      return `Monitoring session ${monitoredSession.shortId} (${targetProjectName})\nWill alert @${mattermostUsername} on permission request, idle, or question\n\n${modeText}`;
+    },
+  });
+}
+
+export function createUnmonitorTool(client: any): ToolDefinition {
+  return tool({
+    description: "Stop monitoring an OpenCode session. Stops all alerts for the specified or current session.",
+    args: {
+      sessionId: tool.schema.string().optional().describe("Session ID to stop monitoring. Defaults to current session if not specified."),
+    },
+    async execute(args) {
+      let targetSessionId = args.sessionId;
+      
+      if (!targetSessionId) {
+        try {
+          const statusResult = await client.session.status();
+          const statusMap = statusResult.data as Record<string, { type: string }> | undefined;
+          if (statusMap && Object.keys(statusMap).length > 0) {
+            const activeSessionIds = Object.keys(statusMap);
+            const busySessionId = activeSessionIds.find(id => statusMap[id]?.type === 'busy');
+            targetSessionId = busySessionId || activeSessionIds[0];
+          }
+        } catch (e) {
+          log.warn("Failed to get session status:", e);
+        }
+      }
+      
+      if (!targetSessionId) {
+        return "No session ID provided and could not determine current session.";
+      }
+      
+      if (!MonitorService.isMonitored(targetSessionId)) {
+        return `Session ${targetSessionId.substring(0, 8)} is not being monitored.`;
+      }
+      
+      MonitorService.unregister(targetSessionId);
+      return `Stopped monitoring session ${targetSessionId.substring(0, 8)}`;
+    },
+  });
+}
+
+async function resolveCurrentSession(client: any, directory: string): Promise<string | undefined> {
+  if (PluginState.openCodeSessionRegistry) {
+    const defaultSession = PluginState.openCodeSessionRegistry.getDefault();
+    if (defaultSession) {
+      return defaultSession.id;
+    }
+  }
+  
+  try {
+    const statusResult = await client.session.status();
+    const statusMap = statusResult.data as Record<string, { type: string }> | undefined;
+    
+    if (statusMap && Object.keys(statusMap).length > 0) {
+      const activeSessionIds = Object.keys(statusMap);
+      const busySessionId = activeSessionIds.find(id => statusMap[id]?.type === 'busy');
+      return busySessionId || activeSessionIds[0];
+    }
+    
+    const sessions = await client.session.list();
+    if (sessions.data && sessions.data.length > 0) {
+      const sortedSessions = [...sessions.data]
+        .filter((s: any) => s.directory === directory)
+        .sort((a: any, b: any) => {
+          const timeA = a.time?.updated || a.time?.created || 0;
+          const timeB = b.time?.updated || b.time?.created || 0;
+          return timeB - timeA;
+        });
+      
+      const currentSession = sortedSessions[0] || sessions.data[0];
+      return currentSession.id;
+    }
+  } catch (e) {
+    log.warn("Failed to get session:", e);
+  }
+  
+  return undefined;
+}

package/.opencode/plugin/mattermost-control/tools/schedule.ts

@@ -0,0 +1,253 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin";
+import { PluginState } from "../state.js";
+import { MattermostClient } from "../../../../src/clients/mattermost-client.js";
+import { getSchedulerService } from "../../../../src/scheduler/scheduler-service.js";
+import { loadConfig } from "../../../../src/config.js";
+import { log } from "../../../../src/logger.js";
+
+export interface ScheduleToolContext {
+  client: any;
+  directory: string;
+  projectName: string;
+}
+
+export function createScheduleAddTool(ctx: ScheduleToolContext): ToolDefinition {
+  return tool({
+    description: "Create a scheduled task that runs a prompt at specified times and DMs you the response. The prompt is injected into the current session at each scheduled time.",
+    args: {
+      name: tool.schema.string().describe("Unique name for this schedule (e.g., 'morning-todos', 'pr-check')"),
+      cron: tool.schema.string().describe("Cron expression for when to run (e.g., '0 8,20 * * *' for 8am and 8pm, '0 */4 * * *' for every 4 hours)"),
+      prompt: tool.schema.string().describe("The prompt to send to the LLM at each scheduled time"),
+      timezone: tool.schema.string().optional().describe("Timezone for the schedule (default: UTC). Examples: 'America/New_York', 'Europe/London'"),
+      targetUser: tool.schema.string().optional().describe("Mattermost username to DM results to. Defaults to current user if connected."),
+    },
+    async execute(args) {
+      const config = loadConfig();
+      const scheduler = getSchedulerService();
+
+      if (!config.mattermost.token) {
+        return "MATTERMOST_TOKEN environment variable is required.";
+      }
+
+      let sessionId: string | undefined;
+      
+      if (PluginState.openCodeSessionRegistry) {
+        const defaultSession = PluginState.openCodeSessionRegistry.getDefault();
+        if (defaultSession) {
+          sessionId = defaultSession.id;
+        }
+      }
+      
+      if (!sessionId) {
+        try {
+          const sessions = await ctx.client.session.list();
+          if (sessions.data && sessions.data.length > 0) {
+            const dirSessions = sessions.data.filter((s: any) => s.directory === ctx.directory);
+            const session = dirSessions[0] || sessions.data[0];
+            sessionId = session.id;
+          }
+        } catch (e) {
+          log.warn("[ScheduleTool] Failed to get session:", e);
+        }
+      }
+
+      if (!sessionId) {
+        return "Could not determine current session. Please ensure an OpenCode session is active.";
+      }
+
+      let targetUserId: string;
+      let targetUsername: string;
+
+      if (args.targetUser) {
+        try {
+          const tempClient = new MattermostClient(config.mattermost);
+          const user = await tempClient.getUserByUsername(args.targetUser.replace(/^@/, ""));
+          targetUserId = user.id;
+          targetUsername = user.username;
+        } catch (e) {
+          return `Could not find Mattermost user: ${args.targetUser}`;
+        }
+      } else if (PluginState.sessionManager) {
+        const sessions = Array.from((PluginState.sessionManager as any).sessions?.values() || []);
+        const userSession = sessions[0] as any;
+        if (userSession) {
+          targetUserId = userSession.mattermostUserId;
+          targetUsername = userSession.mattermostUsername;
+        } else {
+          return "No user session found. Please specify targetUser or ensure you're connected via Mattermost.";
+        }
+      } else {
+        return "targetUser is required when session manager is not available.";
+      }
+
+      try {
+        const schedule = await scheduler.addSchedule({
+          name: args.name,
+          cron: args.cron,
+          timezone: args.timezone,
+          prompt: args.prompt,
+          sessionId,
+          targetUserId,
+          targetUsername,
+        });
+
+        const lines = [
+          `Schedule created: **${schedule.name}**`,
+          "",
+          `| Property | Value |`,
+          `|----------|-------|`,
+          `| Cron | \`${schedule.cron}\` |`,
+          `| Timezone | ${schedule.timezone} |`,
+          `| Session | \`${schedule.sessionId.slice(0, 8)}\` |`,
+          `| Notify | @${schedule.targetUsername} |`,
+          "",
+          `**Prompt:** ${schedule.prompt.slice(0, 100)}${schedule.prompt.length > 100 ? "..." : ""}`,
+        ];
+
+        return lines.join("\n");
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return `Failed to create schedule: ${msg}`;
+      }
+    },
+  });
+}
+
+export function createScheduleListTool(): ToolDefinition {
+  return tool({
+    description: "List all scheduled tasks with their status and next run time.",
+    args: {},
+    async execute() {
+      const scheduler = getSchedulerService();
+      const schedules = scheduler.listSchedules();
+
+      if (schedules.length === 0) {
+        return "No schedules configured. Use `mattermost_schedule_add` to create one.";
+      }
+
+      const lines = [
+        `**Scheduled Tasks (${schedules.length})**`,
+        "",
+        "| Name | Cron | Status | Last Run | Notify |",
+        "|------|------|--------|----------|--------|",
+      ];
+
+      for (const s of schedules) {
+        const status = s.enabled ? (scheduler.isRunning(s.id) ? ":green_circle: Active" : ":yellow_circle: Pending") : ":red_circle: Disabled";
+        const lastRun = s.lastRunAt 
+          ? new Date(s.lastRunAt).toLocaleString() + (s.lastRunSuccess === false ? " :x:" : " :white_check_mark:")
+          : "Never";
+        lines.push(`| ${s.name} | \`${s.cron}\` | ${status} | ${lastRun} | @${s.targetUsername} |`);
+      }
+
+      return lines.join("\n");
+    },
+  });
+}
+
+export function createScheduleRemoveTool(): ToolDefinition {
+  return tool({
+    description: "Remove a scheduled task by name or ID.",
+    args: {
+      name: tool.schema.string().describe("Name or ID of the schedule to remove"),
+    },
+    async execute(args) {
+      const scheduler = getSchedulerService();
+      
+      let removed = scheduler.removeScheduleByName(args.name);
+      if (!removed) {
+        removed = scheduler.removeSchedule(args.name);
+      }
+
+      if (removed) {
+        return `Schedule "${args.name}" removed.`;
+      } else {
+        return `Schedule "${args.name}" not found.`;
+      }
+    },
+  });
+}
+
+export function createScheduleEnableTool(): ToolDefinition {
+  return tool({
+    description: "Enable a disabled scheduled task.",
+    args: {
+      name: tool.schema.string().describe("Name or ID of the schedule to enable"),
+    },
+    async execute(args) {
+      const scheduler = getSchedulerService();
+      
+      let schedule = scheduler.getScheduleByName(args.name);
+      if (!schedule) {
+        schedule = scheduler.getSchedule(args.name);
+      }
+
+      if (!schedule) {
+        return `Schedule "${args.name}" not found.`;
+      }
+
+      if (schedule.enabled) {
+        return `Schedule "${schedule.name}" is already enabled.`;
+      }
+
+      scheduler.enableSchedule(schedule.id);
+      return `Schedule "${schedule.name}" enabled.`;
+    },
+  });
+}
+
+export function createScheduleDisableTool(): ToolDefinition {
+  return tool({
+    description: "Disable a scheduled task without deleting it.",
+    args: {
+      name: tool.schema.string().describe("Name or ID of the schedule to disable"),
+    },
+    async execute(args) {
+      const scheduler = getSchedulerService();
+      
+      let schedule = scheduler.getScheduleByName(args.name);
+      if (!schedule) {
+        schedule = scheduler.getSchedule(args.name);
+      }
+
+      if (!schedule) {
+        return `Schedule "${args.name}" not found.`;
+      }
+
+      if (!schedule.enabled) {
+        return `Schedule "${schedule.name}" is already disabled.`;
+      }
+
+      scheduler.disableSchedule(schedule.id);
+      return `Schedule "${schedule.name}" disabled.`;
+    },
+  });
+}
+
+export function createScheduleRunTool(): ToolDefinition {
+  return tool({
+    description: "Run a scheduled task immediately for testing purposes.",
+    args: {
+      name: tool.schema.string().describe("Name or ID of the schedule to run"),
+    },
+    async execute(args) {
+      const scheduler = getSchedulerService();
+      
+      let schedule = scheduler.getScheduleByName(args.name);
+      if (!schedule) {
+        schedule = scheduler.getSchedule(args.name);
+      }
+
+      if (!schedule) {
+        return `Schedule "${args.name}" not found.`;
+      }
+
+      const ran = await scheduler.runNow(schedule.id);
+      if (ran) {
+        return `Schedule "${schedule.name}" executed. Check your Mattermost DMs for the result.`;
+      } else {
+        return `Failed to execute schedule "${schedule.name}".`;
+      }
+    },
+  });
+}

package/.opencode/plugin/mattermost-control/tools/session.ts

@@ -0,0 +1,120 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin";
+import { PluginState } from "../state.js";
+import { log } from "../../../../src/logger.js";
+
+export function createListSessionsTool() {
+  return {
+    description: "List available OpenCode sessions that can receive prompts from Mattermost",
+    args: {},
+    async execute() {
+      const { isConnected, openCodeSessionRegistry } = PluginState;
+      
+      if (!isConnected || !openCodeSessionRegistry) {
+        return "Not connected to Mattermost. Use mattermost_connect first.";
+      }
+
+      try {
+        await openCodeSessionRegistry.refresh();
+      } catch (e) {
+        log.warn("Failed to refresh sessions:", e);
+      }
+
+      const sessions = openCodeSessionRegistry.listAvailable();
+      if (sessions.length === 0) {
+        return "No active OpenCode sessions found.";
+      }
+
+      const defaultSession = openCodeSessionRegistry.getDefault();
+      const lines = sessions.map((s, i) => {
+        const isDefault = s.id === defaultSession?.id;
+        return `${i + 1}. ${s.projectName} (${s.shortId})${isDefault ? " [default]" : ""}\n   Directory: ${s.directory}`;
+      });
+
+      return `Available OpenCode Sessions:\n\n${lines.join("\n\n")}`;
+    },
+  };
+}
+
+export function createSelectSessionTool(): ToolDefinition {
+  return tool({
+    description: "Select which OpenCode session should receive prompts from a Mattermost user",
+    args: {
+      sessionId: tool.schema.string().describe("Session ID (full or short 6-char ID) or project name"),
+      mattermostUserId: tool.schema.string().optional().describe("Mattermost user ID to set session for (optional, defaults to all users)"),
+    },
+    async execute(args) {
+      const { isConnected, openCodeSessionRegistry, sessionManager } = PluginState;
+      
+      if (!isConnected || !openCodeSessionRegistry || !sessionManager) {
+        return "Not connected to Mattermost. Use mattermost_connect first.";
+      }
+
+      const session = openCodeSessionRegistry.get(args.sessionId);
+      if (!session) {
+        return `Session not found: ${args.sessionId}. Use mattermost_list_sessions to see available sessions.`;
+      }
+
+      if (!session.isAvailable) {
+        return `Session ${session.shortId} (${session.projectName}) is not available.`;
+      }
+
+      if (args.mattermostUserId) {
+        const userSession = sessionManager.getSession(args.mattermostUserId);
+        if (userSession) {
+          userSession.targetOpenCodeSessionId = session.id;
+          return `Set session ${session.shortId} (${session.projectName}) as target for Mattermost user.`;
+        }
+        return `Mattermost user session not found. User must DM the bot first.`;
+      }
+
+      openCodeSessionRegistry.setDefault(session.id);
+      return `Set ${session.shortId} (${session.projectName}) as the default OpenCode session for all Mattermost users.`;
+    },
+  });
+}
+
+export function createCurrentSessionTool(): ToolDefinition {
+  return tool({
+    description: "Show the currently targeted OpenCode session for a Mattermost user",
+    args: {
+      mattermostUserId: tool.schema.string().optional().describe("Mattermost user ID to check (optional, shows default if not specified)"),
+    },
+    async execute(args) {
+      const { isConnected, openCodeSessionRegistry, sessionManager } = PluginState;
+      
+      if (!isConnected || !openCodeSessionRegistry || !sessionManager) {
+        return "Not connected to Mattermost. Use mattermost_connect first.";
+      }
+
+      if (args.mattermostUserId) {
+        const userSession = sessionManager.getSession(args.mattermostUserId);
+        if (!userSession) {
+          return `No active Mattermost session for user ${args.mattermostUserId}. User must DM the bot first.`;
+        }
+
+        const targetId = userSession.targetOpenCodeSessionId;
+        if (!targetId) {
+          const defaultSession = openCodeSessionRegistry.getDefault();
+          if (defaultSession) {
+            return `User @${userSession.mattermostUsername} has no explicit session selected.\nUsing default: ${defaultSession.projectName} (${defaultSession.shortId})\nDirectory: ${defaultSession.directory}`;
+          }
+          return `User @${userSession.mattermostUsername} has no session selected and no default is available.`;
+        }
+
+        const session = openCodeSessionRegistry.get(targetId);
+        if (!session || !session.isAvailable) {
+          return `User @${userSession.mattermostUsername}'s selected session is no longer available.`;
+        }
+
+        return `User @${userSession.mattermostUsername} is targeting:\nProject: ${session.projectName}\nID: ${session.shortId}\nDirectory: ${session.directory}\nLast updated: ${session.lastUpdated.toISOString()}`;
+      }
+
+      const defaultSession = openCodeSessionRegistry.getDefault();
+      if (!defaultSession) {
+        return "No default OpenCode session is set. Use mattermost_list_sessions to see available sessions.";
+      }
+
+      return `Default OpenCode session:\nProject: ${defaultSession.projectName}\nID: ${defaultSession.shortId}\nDirectory: ${defaultSession.directory}\nLast updated: ${defaultSession.lastUpdated.toISOString()}`;
+    },
+  });
+}

package/.opencode/plugin/mattermost-control/types.ts

@@ -0,0 +1,107 @@
+/**
+ * Type definitions for the Mattermost Control Plugin
+ * 
+ * This module contains all TypeScript interfaces used across the plugin.
+ * It has NO local imports to prevent circular dependencies.
+ */
+
+/**
+ * Represents a currently executing tool
+ */
+export interface ActiveTool {
+  name: string;
+  startTime: number;
+}
+
+/**
+ * A task item from OpenCode's todo system
+ */
+export interface TodoItem {
+  id: string;
+  content: string;
+  status: string;
+  priority: string;
+}
+
+/**
+ * Token usage information
+ */
+export interface TokenInfo {
+  input: number;
+  output: number;
+  reasoning: number;
+  cache: {
+    read: number;
+    write: number;
+  };
+}
+
+/**
+ * Cost and token tracking for a message/session
+ */
+export interface CostInfo {
+  sessionTotal: number;
+  currentMessage: number;
+  tokens: TokenInfo;
+}
+
+/**
+ * Per-session context tracking an active response stream
+ */
+export interface ResponseContext {
+  opencodeSessionId: string;
+  mmSession: any;
+  streamCtx: any;
+  threadRootPostId?: string;
+  responseBuffer: string;
+  thinkingBuffer: string;
+  toolCalls: string[];
+  activeTool: ActiveTool | null;
+  shellOutput: string;
+  shellOutputLastUpdate: number;
+  lastUpdateTime: number;
+  textPartCount?: number;
+  reasoningPartCount?: number;
+  compactionCount: number;
+  todos: TodoItem[];
+  cost: CostInfo;
+  responseStartTime: number;
+  compactionPostId?: string;
+  awaitingContinuation: boolean;
+  inCompactionSummary: boolean;
+}
+
+/**
+ * Creates a new empty ResponseContext
+ */
+export function createEmptyResponseContext(
+  opencodeSessionId: string,
+  mmSession: any,
+  streamCtx: any,
+  threadRootPostId?: string,
+  sessionTotalCost: number = 0
+): ResponseContext {
+  return {
+    opencodeSessionId,
+    mmSession,
+    streamCtx,
+    threadRootPostId,
+    responseBuffer: "",
+    thinkingBuffer: "",
+    toolCalls: [],
+    activeTool: null,
+    shellOutput: "",
+    shellOutputLastUpdate: 0,
+    lastUpdateTime: Date.now(),
+    compactionCount: 0,
+    todos: [],
+    cost: {
+      sessionTotal: sessionTotalCost,
+      currentMessage: 0,
+      tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+    },
+    responseStartTime: Date.now(),
+    awaitingContinuation: false,
+    inCompactionSummary: false,
+  };
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shakudo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.