@dinhtungdu/watcher 1.0.0

package/src/agentEventReducer.ts

@@ -0,0 +1,336 @@
+import { AgentActivityItem, AgentPane, AgentStatus, GitMetadata, ObservationCapability, TerminalTarget } from './model.js';
+import { WatcherAgentEventInput, WatcherAgentEventPayload } from './agentEvents.js';
+import { canonicalSurfaceKey } from './surfaceIdentity.js';
+
+export interface AgentEventContext {
+  target: TerminalTarget;
+  cwd?: string;
+  git?: GitMetadata;
+  now: number;
+}
+
+export function mapAgentEventToStatus(type: WatcherAgentEventInput['type']): AgentStatus {
+  switch (type) {
+    case 'session-started':
+      return 'unknown';
+    case 'agent-started':
+      return 'working';
+    case 'user-message':
+    case 'assistant-delta':
+    case 'assistant-message':
+    case 'tool-started':
+    case 'tool-updated':
+    case 'tool-finished':
+      return 'working';
+    case 'needs-input':
+    case 'error':
+      return 'needs_input';
+    case 'agent-finished':
+      return 'idle';
+  }
+}
+
+function summarize(value: string | undefined, fallback: string): string {
+  if (!value) return fallback;
+  const oneLine = value.replace(/\s+/g, ' ').trim();
+  return oneLine.length > 140 ? `${oneLine.slice(0, 139)}…` : oneLine;
+}
+
+function isPlaceholderSummary(value: string | undefined): boolean {
+  return !value
+    || value === 'Waiting for first task'
+    || value === 'Finished'
+    || value.startsWith('Detected ');
+}
+
+function eventObservation(previous: AgentPane | undefined, type: WatcherAgentEventInput['type']): ObservationCapability {
+  const terminalPreview = previous?.observation?.terminalPreview ?? false;
+  const assistantDeltas = (previous?.observation?.assistantDeltas ?? false) || type === 'assistant-delta';
+  return {
+    source: terminalPreview ? 'mixed' : 'event-source',
+    semanticEvents: true,
+    assistantDeltas,
+    terminalPreview,
+  };
+}
+
+function basePane(previous: AgentPane | undefined, input: WatcherAgentEventInput, context: AgentEventContext, status: AgentStatus): AgentPane {
+  return {
+    ...previous,
+    id: canonicalSurfaceKey(input.surface),
+    agentType: input.agent,
+    status,
+    reportedStatus: status === 'stalled' ? 'working' : status,
+    summary: previous?.summary ?? 'Waiting for first task',
+    target: context.target,
+    cwd: context.cwd,
+    git: context.git,
+    updatedAt: input.now ?? context.now,
+    observation: eventObservation(previous, input.type),
+  };
+}
+
+function assistantActivityId(payload: WatcherAgentEventPayload): string {
+  return `assistant:${payload.messageId ?? 'current'}`;
+}
+
+function toolActivityId(payload: WatcherAgentEventPayload): string | undefined {
+  return payload.id ? `tool:${payload.id}` : undefined;
+}
+
+function mergeActivityItems(previous: AgentActivityItem[] | undefined, updates: AgentActivityItem[], maxItems = 3): AgentActivityItem[] | undefined {
+  if (!previous?.length && updates.length === 0) return undefined;
+  const byId = new Map<string, AgentActivityItem>();
+  for (const item of previous ?? []) byId.set(item.id, item);
+  for (const item of updates) {
+    const existing = byId.get(item.id);
+    byId.set(item.id, existing ? { ...existing, ...item } : item);
+  }
+  const items = [...byId.values()].sort((a, b) => b.updatedAt - a.updatedAt).slice(0, maxItems);
+  return items.length > 0 ? items : undefined;
+}
+
+function summaryAfterNonUserEvent(previous: AgentPane | undefined, fallbackText: string | undefined, fallbackSummary: string): string {
+  if (previous?.userMessage) return previous.summary;
+  if (previous?.summary && !isPlaceholderSummary(previous.summary) && !fallbackText) return previous.summary;
+  return summarize(fallbackText, fallbackSummary);
+}
+
+function nonEmpty(value: string | undefined): string | undefined {
+  return value?.trim() ? value : undefined;
+}
+
+function finalAssistantMessage(previous: AgentPane | undefined, payload: WatcherAgentEventPayload): string | undefined {
+  return nonEmpty(payload.finalMessage) ?? nonEmpty(previous?.pendingAssistantMessage) ?? nonEmpty(previous?.lastMessage);
+}
+
+export function applyAgentEvent(previous: AgentPane | undefined, input: WatcherAgentEventInput, context: AgentEventContext): AgentPane {
+  const now = input.now ?? context.now;
+  const status = mapAgentEventToStatus(input.type);
+  const pane = basePane(previous, input, context, status);
+  const payload = input.payload;
+
+  if (previous?.status === 'idle') {
+    if (input.type === 'assistant-message') {
+      const text = payload.text!;
+      return {
+        ...pane,
+        status: 'idle',
+        reportedStatus: 'idle',
+        summary: previous.summary,
+        userMessage: previous.userMessage,
+        lastMessage: text,
+        pendingAssistantMessage: undefined,
+        activityItems: undefined,
+        currentAction: undefined,
+      };
+    }
+    if (input.type !== 'session-started' && input.type !== 'agent-started' && input.type !== 'user-message' && input.type !== 'needs-input' && input.type !== 'error') {
+      return {
+        ...pane,
+        status: 'idle',
+        reportedStatus: 'idle',
+        summary: previous.summary,
+        userMessage: previous.userMessage,
+        lastMessage: previous.lastMessage,
+        pendingAssistantMessage: undefined,
+        activityItems: undefined,
+        currentAction: undefined,
+      };
+    }
+  }
+
+  switch (input.type) {
+    case 'session-started':
+      return {
+        ...pane,
+        summary: 'Waiting for first task',
+        userMessage: undefined,
+        lastMessage: undefined,
+        pendingAssistantMessage: undefined,
+        activityItems: undefined,
+        currentAction: undefined,
+      };
+
+    case 'agent-started':
+      return {
+        ...pane,
+        summary: previous?.summary ?? 'Working',
+        userMessage: previous?.userMessage,
+        lastMessage: undefined,
+        pendingAssistantMessage: undefined,
+        activityItems: undefined,
+        currentAction: 'Working',
+      };
+
+    case 'user-message': {
+      const text = payload.text!;
+      return {
+        ...pane,
+        summary: summarize(text, 'User message'),
+        userMessage: text,
+        lastMessage: undefined,
+        pendingAssistantMessage: undefined,
+        activityItems: undefined,
+        currentAction: undefined,
+      };
+    }
+
+    case 'assistant-delta': {
+      const text = payload.text!;
+      return {
+        ...pane,
+        summary: summaryAfterNonUserEvent(previous, text, 'Responding'),
+        userMessage: previous?.userMessage,
+        lastMessage: previous?.lastMessage,
+        pendingAssistantMessage: previous?.pendingAssistantMessage,
+        currentAction: 'Responding',
+        activityItems: mergeActivityItems(previous?.activityItems, [{
+          id: assistantActivityId(payload),
+          kind: 'assistant',
+          label: 'assistant',
+          text,
+          state: 'running',
+          updatedAt: now,
+        }]),
+      };
+    }
+
+    case 'assistant-message': {
+      const text = payload.text!;
+      return {
+        ...pane,
+        summary: summaryAfterNonUserEvent(previous, text, 'Assistant message'),
+        userMessage: previous?.userMessage,
+        lastMessage: previous?.lastMessage,
+        pendingAssistantMessage: text,
+        currentAction: undefined,
+        activityItems: mergeActivityItems(previous?.activityItems, [{
+          id: assistantActivityId(payload),
+          kind: 'assistant',
+          label: 'assistant',
+          text,
+          state: 'done',
+          updatedAt: now,
+        }]),
+      };
+    }
+
+    case 'tool-started': {
+      const name = payload.name!;
+      return {
+        ...pane,
+        summary: previous?.userMessage ? previous.summary : summarize(`Running ${name}`, `Running ${name}`),
+        userMessage: previous?.userMessage,
+        lastMessage: previous?.lastMessage,
+        pendingAssistantMessage: previous?.pendingAssistantMessage,
+        currentAction: name,
+        activityItems: mergeActivityItems(previous?.activityItems, [{
+          id: toolActivityId(payload)!,
+          kind: 'tool',
+          label: name,
+          text: payload.input,
+          state: 'running',
+          updatedAt: now,
+        }]),
+      };
+    }
+
+    case 'tool-updated': {
+      const activityId = toolActivityId(payload)!;
+      const previousItem = previous?.activityItems?.find((item) => item.id === activityId);
+      const name = payload.name ?? previousItem?.label ?? previous?.currentAction ?? 'tool';
+      return {
+        ...pane,
+        summary: previous?.userMessage ? previous.summary : (previous?.summary ?? `Running ${name}`),
+        userMessage: previous?.userMessage,
+        lastMessage: previous?.lastMessage,
+        pendingAssistantMessage: previous?.pendingAssistantMessage,
+        currentAction: name,
+        activityItems: mergeActivityItems(previous?.activityItems, [{
+          id: activityId,
+          kind: 'tool',
+          label: name,
+          text: payload.text ?? previousItem?.text,
+          state: 'running',
+          updatedAt: now,
+        }]),
+      };
+    }
+
+    case 'tool-finished': {
+      const activityId = toolActivityId(payload)!;
+      const previousItem = previous?.activityItems?.find((item) => item.id === activityId);
+      const name = payload.name ?? previousItem?.label ?? 'tool';
+      return {
+        ...pane,
+        summary: previous?.userMessage ? previous.summary : (previous?.summary ?? `Finished ${name}`),
+        userMessage: previous?.userMessage,
+        lastMessage: previous?.lastMessage,
+        pendingAssistantMessage: previous?.pendingAssistantMessage,
+        currentAction: undefined,
+        activityItems: mergeActivityItems(previous?.activityItems, [{
+          id: activityId,
+          kind: 'tool',
+          label: name,
+          text: payload.output ?? previousItem?.text,
+          state: payload.error ? 'error' : 'done',
+          updatedAt: now,
+        }]),
+      };
+    }
+
+    case 'needs-input': {
+      const activityId = toolActivityId(payload);
+      const previousItem = activityId ? previous?.activityItems?.find((item) => item.id === activityId) : undefined;
+      const updates: AgentActivityItem[] = activityId ? [{
+        id: activityId,
+        kind: 'tool',
+        label: payload.name ?? previousItem?.label ?? 'tool',
+        text: payload.text ?? payload.reason ?? previousItem?.text,
+        state: 'waiting',
+        updatedAt: now,
+      }] : [];
+      const currentAction = payload.text ?? payload.reason ?? 'Needs input';
+      return {
+        ...pane,
+        summary: previous?.userMessage ? previous.summary : summarize(currentAction, 'Needs input'),
+        userMessage: previous?.userMessage,
+        lastMessage: previous?.lastMessage,
+        pendingAssistantMessage: previous?.pendingAssistantMessage,
+        currentAction,
+        activityItems: mergeActivityItems(previous?.activityItems, updates),
+      };
+    }
+
+    case 'error': {
+      const currentAction = payload.reason ?? 'error';
+      return {
+        ...pane,
+        summary: previous?.userMessage ? previous.summary : summarize(currentAction, 'error'),
+        userMessage: previous?.userMessage,
+        lastMessage: previous?.lastMessage,
+        pendingAssistantMessage: previous?.pendingAssistantMessage,
+        currentAction,
+        activityItems: previous?.activityItems,
+      };
+    }
+
+    case 'agent-finished': {
+      const finalMessage = finalAssistantMessage(previous, payload);
+      return {
+        ...pane,
+        summary: previous?.userMessage
+          ? previous.summary
+          : previous?.summary && !isPlaceholderSummary(previous.summary)
+            ? previous.summary
+            : summarize(finalMessage, 'Finished'),
+        userMessage: previous?.userMessage,
+        lastMessage: finalMessage,
+        pendingAssistantMessage: undefined,
+        activityItems: undefined,
+        currentAction: undefined,
+      };
+    }
+  }
+}

package/src/agentEvents.ts

@@ -0,0 +1,188 @@
+import path from 'node:path';
+import type { AgentType } from './model.js';
+import { isAgentType } from './agents/registry.js';
+import { EventSurfaceIdentity, tmuxSurface } from './surfaceIdentity.js';
+
+export const MAX_EVENT_TEXT = 16_000;
+
+export const WATCHER_AGENT_EVENT_TYPES = [
+  'session-started',
+  'agent-started',
+  'user-message',
+  'assistant-delta',
+  'assistant-message',
+  'tool-started',
+  'tool-updated',
+  'tool-finished',
+  'needs-input',
+  'agent-finished',
+  'error',
+] as const;
+
+export type WatcherAgentEventType = typeof WATCHER_AGENT_EVENT_TYPES[number];
+
+export interface WatcherAgentEventPayload {
+  cwd?: string;
+  reason?: string;
+  text?: string;
+  messageId?: string;
+  finalMessage?: string;
+  id?: string;
+  name?: string;
+  input?: string;
+  output?: string;
+  error?: boolean;
+}
+
+export interface WatcherAgentEventInput {
+  agent: AgentType;
+  type: WatcherAgentEventType;
+  surface: EventSurfaceIdentity;
+  payload: WatcherAgentEventPayload;
+  now?: number;
+}
+
+export class AgentEventValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'AgentEventValidationError';
+  }
+}
+
+export function isWatcherAgentEventType(value: string): value is WatcherAgentEventType {
+  return WATCHER_AGENT_EVENT_TYPES.includes(value as WatcherAgentEventType);
+}
+
+export function readJsonObject(input: string): Record<string, unknown> {
+  if (!input.trim()) return {};
+  const parsed = JSON.parse(input) as unknown;
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new AgentEventValidationError('event payload must be a JSON object');
+  }
+  return parsed as Record<string, unknown>;
+}
+
+function requireString(payload: Record<string, unknown>, key: string): string {
+  const value = payload[key];
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new AgentEventValidationError(`event payload requires non-empty string field: ${key}`);
+  }
+  return capEventText(value.trim());
+}
+
+function optionalString(payload: Record<string, unknown>, key: string): string | undefined {
+  const value = payload[key];
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== 'string') throw new AgentEventValidationError(`event payload field must be a string: ${key}`);
+  const text = value.trim();
+  return text ? capEventText(text) : undefined;
+}
+
+function optionalBoolean(payload: Record<string, unknown>, key: string): boolean | undefined {
+  const value = payload[key];
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== 'boolean') throw new AgentEventValidationError(`event payload field must be a boolean: ${key}`);
+  return value;
+}
+
+export function capEventText(value: string): string {
+  return value.length > MAX_EVENT_TEXT ? `${value.slice(0, MAX_EVENT_TEXT - 1)}…` : value;
+}
+
+export function compactEventValue(value: unknown): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  let text: string;
+  try {
+    text = typeof value === 'string' ? value : JSON.stringify(value);
+  } catch {
+    text = String(value);
+  }
+  text = (text ?? '').replace(/\s+/g, ' ').trim();
+  return text ? capEventText(text) : undefined;
+}
+
+function optionalCompactValue(payload: Record<string, unknown>, key: string): string | undefined {
+  if (!(key in payload)) return undefined;
+  return compactEventValue(payload[key]);
+}
+
+function optionalCwd(payload: Record<string, unknown>): string | undefined {
+  const cwd = optionalString(payload, 'cwd');
+  return cwd && path.isAbsolute(cwd) ? cwd : undefined;
+}
+
+function parseSurface(value: unknown): EventSurfaceIdentity | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const record = value as Record<string, unknown>;
+  if (record.backend !== 'tmux') throw new AgentEventValidationError('event surface backend must be tmux');
+  if (typeof record.id !== 'string' || !record.id.trim()) throw new AgentEventValidationError('event surface requires non-empty id');
+  return { backend: 'tmux', id: record.id.trim() };
+}
+
+export function resolveEventSurface(payload: Record<string, unknown>, fallbackTmuxPaneId?: string): EventSurfaceIdentity {
+  const explicit = parseSurface(payload.surface);
+  if (explicit) return explicit;
+  if (fallbackTmuxPaneId?.trim()) return tmuxSurface(fallbackTmuxPaneId.trim());
+  throw new AgentEventValidationError('event requires surface identity or TMUX_PANE fallback');
+}
+
+export function normalizeWatcherAgentEventPayload(type: WatcherAgentEventType, payload: Record<string, unknown>): WatcherAgentEventPayload {
+  const common: WatcherAgentEventPayload = { cwd: optionalCwd(payload) };
+  switch (type) {
+    case 'session-started':
+      return { ...common, reason: optionalString(payload, 'reason') };
+    case 'agent-started':
+      return common;
+    case 'user-message':
+      return { ...common, text: requireString(payload, 'text') };
+    case 'assistant-delta':
+    case 'assistant-message':
+      return { ...common, messageId: optionalString(payload, 'messageId'), text: requireString(payload, 'text') };
+    case 'tool-started':
+      return { ...common, id: requireString(payload, 'id'), name: requireString(payload, 'name'), input: optionalCompactValue(payload, 'input') };
+    case 'tool-updated':
+      return { ...common, id: requireString(payload, 'id'), name: optionalString(payload, 'name'), text: optionalString(payload, 'text') };
+    case 'tool-finished':
+      return {
+        ...common,
+        id: requireString(payload, 'id'),
+        name: optionalString(payload, 'name'),
+        output: optionalCompactValue(payload, 'output'),
+        error: optionalBoolean(payload, 'error'),
+      };
+    case 'needs-input':
+      return {
+        ...common,
+        reason: optionalString(payload, 'reason'),
+        text: optionalString(payload, 'text'),
+        id: optionalString(payload, 'id'),
+        name: optionalString(payload, 'name'),
+      };
+    case 'agent-finished':
+      return { ...common, finalMessage: optionalString(payload, 'finalMessage') };
+    case 'error':
+      return { ...common, reason: optionalString(payload, 'reason') };
+  }
+}
+
+export interface BuildWatcherAgentEventOptions {
+  fallbackTmuxPaneId?: string;
+  now?: number;
+}
+
+export function buildWatcherAgentEventInput(
+  agent: string | undefined,
+  type: string | undefined,
+  payload: Record<string, unknown>,
+  options: BuildWatcherAgentEventOptions = {},
+): WatcherAgentEventInput {
+  if (!agent || !isAgentType(agent)) throw new AgentEventValidationError(`unknown agent integration: ${agent ?? '(missing)'}`);
+  if (!type || !isWatcherAgentEventType(type)) throw new AgentEventValidationError(`unknown Watcher Agent Event: ${type ?? '(missing)'}`);
+  return {
+    agent,
+    type,
+    surface: resolveEventSurface(payload, options.fallbackTmuxPaneId),
+    payload: normalizeWatcherAgentEventPayload(type, payload),
+    now: options.now,
+  };
+}

package/src/agents/claude.ts

@@ -0,0 +1,16 @@
+import { AgentIntegration, commandAliasDetector } from './types.js';
+
+const commandAliases = ['claude', 'claude-code'];
+
+export const claudeIntegration: AgentIntegration = {
+  type: 'claude',
+  displayName: 'Claude',
+  commandAliases,
+  capabilities: {
+    eventIngestion: 'supported',
+    eventSourceInstall: 'not-implemented',
+    activityEvents: 'unknown',
+    assistantDeltas: 'unknown',
+  },
+  detectProcess: commandAliasDetector(commandAliases),
+};

package/src/agents/codex.ts

@@ -0,0 +1,16 @@
+import { AgentIntegration, commandAliasDetector } from './types.js';
+
+const commandAliases = ['codex'];
+
+export const codexIntegration: AgentIntegration = {
+  type: 'codex',
+  displayName: 'Codex',
+  commandAliases,
+  capabilities: {
+    eventIngestion: 'supported',
+    eventSourceInstall: 'not-implemented',
+    activityEvents: 'not-implemented',
+    assistantDeltas: 'unknown',
+  },
+  detectProcess: commandAliasDetector(commandAliases),
+};

package/src/agents/opencode.ts

@@ -0,0 +1,16 @@
+import { AgentIntegration, commandAliasDetector } from './types.js';
+
+const commandAliases = ['opencode'];
+
+export const opencodeIntegration: AgentIntegration = {
+  type: 'opencode',
+  displayName: 'OpenCode',
+  commandAliases,
+  capabilities: {
+    eventIngestion: 'supported',
+    eventSourceInstall: 'not-implemented',
+    activityEvents: 'not-implemented',
+    assistantDeltas: 'not-implemented',
+  },
+  detectProcess: commandAliasDetector(commandAliases),
+};

package/src/agents/pi.ts

@@ -0,0 +1,16 @@
+import { AgentIntegration, commandAliasDetector } from './types.js';
+
+const commandAliases = ['pi'];
+
+export const piIntegration: AgentIntegration = {
+  type: 'pi',
+  displayName: 'Pi',
+  commandAliases,
+  capabilities: {
+    eventIngestion: 'supported',
+    eventSourceInstall: 'supported',
+    activityEvents: 'supported',
+    assistantDeltas: 'not-implemented',
+  },
+  detectProcess: commandAliasDetector(commandAliases),
+};

package/src/agents/registry.ts

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import type { AgentType } from '../model.js';
+import type { AgentIntegration, AgentProcessInfo } from './types.js';
+import { claudeIntegration } from './claude.js';
+import { codexIntegration } from './codex.js';
+import { opencodeIntegration } from './opencode.js';
+import { piIntegration } from './pi.js';
+
+export const AGENT_INTEGRATIONS = [
+  piIntegration,
+  claudeIntegration,
+  codexIntegration,
+  opencodeIntegration,
+] as const satisfies readonly AgentIntegration[];
+
+export const AGENT_TYPES = AGENT_INTEGRATIONS.map((integration) => integration.type) as AgentType[];
+
+export function isAgentType(value: string): value is AgentType {
+  return AGENT_TYPES.includes(value as AgentType);
+}
+
+export function getAgentIntegration(agent: AgentType): AgentIntegration {
+  const integration = AGENT_INTEGRATIONS.find((candidate) => candidate.type === agent);
+  if (!integration) throw new Error(`unknown agent integration: ${agent}`);
+  return integration;
+}
+
+export function normalizeAgentCommand(command: string | undefined): string | undefined {
+  if (!command) return undefined;
+  const base = path.basename(command).toLowerCase();
+  return base.replace(/\.(js|mjs|cjs|ts|tsx)$/u, '');
+}
+
+export function detectAgentFromProcess(process: AgentProcessInfo): AgentType | undefined {
+  const normalized: AgentProcessInfo = {
+    ...process,
+    command: normalizeAgentCommand(process.command),
+  };
+  return AGENT_INTEGRATIONS.find((integration) => integration.detectProcess(normalized))?.type;
+}
+
+export function commandAliasCollisions(): string[] {
+  const seen = new Map<string, AgentType>();
+  const collisions: string[] = [];
+  for (const integration of AGENT_INTEGRATIONS) {
+    for (const alias of integration.commandAliases) {
+      const normalized = normalizeAgentCommand(alias) ?? alias;
+      const previous = seen.get(normalized);
+      if (previous && previous !== integration.type) collisions.push(`${normalized}:${previous}/${integration.type}`);
+      seen.set(normalized, integration.type);
+    }
+  }
+  return collisions;
+}

package/src/agents/types.ts

@@ -0,0 +1,28 @@
+import type { AgentType } from '../model.js';
+
+export type CapabilitySupport = 'supported' | 'not-implemented' | 'unsupported' | 'unknown';
+
+export interface AgentIntegrationCapabilities {
+  eventIngestion: CapabilitySupport;
+  eventSourceInstall: CapabilitySupport;
+  activityEvents: CapabilitySupport;
+  assistantDeltas: CapabilitySupport;
+}
+
+export interface AgentProcessInfo {
+  command?: string;
+  args?: string;
+}
+
+export interface AgentIntegration {
+  type: AgentType;
+  displayName: string;
+  commandAliases: string[];
+  capabilities: AgentIntegrationCapabilities;
+  detectProcess(process: AgentProcessInfo): boolean;
+}
+
+export function commandAliasDetector(commandAliases: string[]): (process: AgentProcessInfo) => boolean {
+  const aliases = new Set(commandAliases);
+  return (process) => Boolean(process.command && aliases.has(process.command));
+}