amalgm 0.1.51 → 0.1.53

package/runtime/scripts/amalgm-mcp/artifacts/rest.js

@@ -1,103 +0,0 @@
-/**
- * /artifacts/* REST routes for the Next.js API and local tunnel runtime.
- */
-
-const { getConnectedRoutes, loadArtifacts } = require('./store');
-const {
-  deleteArtifact,
-  connectDns,
-  disconnectDns,
-  redeployArtifact,
-  registerArtifact,
-  startArtifact,
-  stopArtifact,
-} = require('./supervisor');
-
-async function handleList(sendJson) {
-  sendJson(200, loadArtifacts());
-}
-
-async function handleRoutes(sendJson) {
-  sendJson(200, { routes: getConnectedRoutes() });
-}
-
-async function handleRegister(body, sendJson) {
-  try {
-    const artifact = await registerArtifact(body || {});
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleRedeploy(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await redeployArtifact(body.artifact_id, body);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleStart(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await startArtifact(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleStop(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await stopArtifact(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleDelete(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await deleteArtifact(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleConnectDns(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await connectDns(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-async function handleDisconnectDns(body, sendJson) {
-  try {
-    if (!body?.artifact_id) return sendJson(400, { error: 'artifact_id is required' });
-    const artifact = await disconnectDns(body.artifact_id);
-    sendJson(200, { artifact });
-  } catch (err) {
-    sendJson(400, { error: err instanceof Error ? err.message : String(err) });
-  }
-}
-
-module.exports = {
-  handleConnectDns,
-  handleDelete,
-  handleDisconnectDns,
-  handleList,
-  handleRedeploy,
-  handleRegister,
-  handleRoutes,
-  handleStart,
-  handleStop,
-};

package/runtime/scripts/amalgm-mcp/artifacts/store.js

@@ -1,157 +0,0 @@
-/**
- * Artifact storage — ~/.amalgm/artifacts.json
- *
- * This is intentionally local-first. The laptop volume is the source of truth;
- * the public gateway only gets ephemeral route advertisements while the
- * computer is connected.
- */
-
-const crypto = require('crypto');
-const {
-  ARTIFACTS_DIR,
-  ARTIFACTS_FILE,
-  ARTIFACTS_DOMAIN,
-  ARTIFACT_PORT_MIN,
-  ARTIFACT_PORT_MAX,
-} = require('../config');
-const { ensureDir, readJson, writeJsonAtomic } = require('../lib/storage');
-const { appendStateEvent } = require('../state/events');
-
-function ensureArtifactsDirs() {
-  ensureDir(ARTIFACTS_DIR);
-  if (!readJson(ARTIFACTS_FILE, null)) {
-    writeJsonAtomic(ARTIFACTS_FILE, { version: 1, artifacts: [] });
-  }
-}
-
-function publicUrlForRef(artifactRef) {
-  return `https://${artifactRef}.${ARTIFACTS_DOMAIN}/`;
-}
-
-function genArtifactRef() {
-  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
-  const bytes = crypto.randomBytes(12);
-  let out = '';
-  for (let i = 0; i < 12; i += 1) {
-    out += chars[bytes[i] % chars.length];
-  }
-  return out;
-}
-
-function normalizeArtifact(artifact) {
-  const artifactRef = artifact.artifactRef || artifact.artifact_ref || genArtifactRef();
-  const dnsConnected =
-    artifact.dnsConnected !== undefined
-      ? artifact.dnsConnected !== false
-      : artifact.connected !== false;
-
-  return {
-    ...artifact,
-    kind: 'artifact',
-    artifactRef,
-    artifact_ref: artifactRef,
-    publicUrl: artifact.publicUrl || publicUrlForRef(artifactRef),
-    dnsConnected,
-    autostart: artifact.autostart !== false,
-    keepAlive: artifact.keepAlive !== false,
-    desiredState: artifact.desiredState || (artifact.status === 'stopped' ? 'stopped' : 'running'),
-    status: artifact.status || 'stopped',
-    pid: artifact.pid || null,
-    error: artifact.error || null,
-  };
-}
-
-function loadArtifacts() {
-  const data = readJson(ARTIFACTS_FILE, { version: 1, artifacts: [] });
-  const artifacts = Array.isArray(data.artifacts) ? data.artifacts.map(normalizeArtifact) : [];
-  return { version: 1, artifacts };
-}
-
-function publishArtifactsChange(data, source = 'artifacts') {
-  try {
-    appendStateEvent({
-      resource: 'artifacts',
-      op: 'replace',
-      value: Array.isArray(data?.artifacts) ? data.artifacts.map(normalizeArtifact) : [],
-      source,
-    });
-  } catch (error) {
-    console.warn('[Artifacts] Local Live Store publish failed:', error.message);
-  }
-}
-
-function saveArtifacts(data, options = {}) {
-  ensureDir(ARTIFACTS_DIR);
-  const normalizedData = {
-    version: 1,
-    artifacts: Array.isArray(data.artifacts) ? data.artifacts.map(normalizeArtifact) : [],
-  };
-  writeJsonAtomic(ARTIFACTS_FILE, normalizedData);
-  publishArtifactsChange(normalizedData, options.source || 'artifacts:save');
-}
-
-function updateArtifactMeta(artifactId, updates) {
-  const data = loadArtifacts();
-  const artifact = data.artifacts.find((item) => item.id === artifactId);
-  if (!artifact) return null;
-  Object.assign(artifact, updates, { updatedAt: new Date().toISOString() });
-  saveArtifacts(data);
-  return normalizeArtifact(artifact);
-}
-
-function getArtifact(artifactId) {
-  return loadArtifacts().artifacts.find((artifact) => artifact.id === artifactId) || null;
-}
-
-function allocatePort(preferredPort) {
-  if (preferredPort !== undefined && preferredPort !== null) {
-    const parsed = Number(preferredPort);
-    if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535) return parsed;
-    return null;
-  }
-
-  const used = new Set(loadArtifacts().artifacts.map((artifact) => Number(artifact.port)));
-  for (let port = ARTIFACT_PORT_MIN; port <= ARTIFACT_PORT_MAX; port += 1) {
-    if (!used.has(port)) return port;
-  }
-  return null;
-}
-
-function allocateUniqueArtifactRef() {
-  const used = new Set(loadArtifacts().artifacts.map((artifact) => artifact.artifactRef));
-  for (let attempt = 0; attempt < 12; attempt += 1) {
-    const candidate = genArtifactRef();
-    if (!used.has(candidate)) return candidate;
-  }
-  throw new Error('Could not allocate artifact DNS ref');
-}
-
-function getConnectedRoutes() {
-  return loadArtifacts()
-    .artifacts
-    .filter((artifact) =>
-      artifact.dnsConnected
-      && artifact.desiredState === 'running'
-      && artifact.status !== 'stopped'
-      && artifact.status !== 'error'
-      && artifact.port
-      && artifact.artifactRef,
-    )
-    .map((artifact) => ({
-      artifact_ref: artifact.artifactRef,
-      port: artifact.port,
-      name: artifact.name,
-    }));
-}
-
-module.exports = {
-  allocatePort,
-  allocateUniqueArtifactRef,
-  ensureArtifactsDirs,
-  getArtifact,
-  getConnectedRoutes,
-  loadArtifacts,
-  publicUrlForRef,
-  saveArtifacts,
-  updateArtifactMeta,
-};

package/runtime/scripts/amalgm-mcp/artifacts/supervisor.js

@@ -1,439 +0,0 @@
-/**
- * Minimal artifact supervisor.
- *
- * Runs user-provided commands. It does not scaffold, wrap, or impose an app
- * framework. The artifact process is expected to bind to PORT / {port}.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-const { DEFAULT_CWD } = require('../config');
-const activeMemory = require('../../chat-core/tooling/active-memory');
-const { runtimePort } = require('../../../lib/runtime-manifest');
-const { syncArtifactRoutesToGateway } = require('./advertise');
-const {
-  allocatePort,
-  allocateUniqueArtifactRef,
-  getArtifact,
-  loadArtifacts,
-  publicUrlForRef,
-  saveArtifacts,
-  updateArtifactMeta,
-} = require('./store');
-
-const running = new Map();
-const stopping = new Set();
-const restartTimers = new Map();
-
-const ARTIFACT_ENV_ALLOWLIST = [
-  'AMALGM_BIND_HOST',
-  'AMALGM_DIR',
-  'AMALGM_GATEWAY_PORT',
-  'AMALGM_MCP_PORT',
-  'AMALGM_RUNTIME_TOKEN',
-  'AMALGM_WORKSPACES_DIR',
-  'CHAT_SERVER_PORT',
-  'PATH',
-  'HOME',
-  'USER',
-  'LOGNAME',
-  'SHELL',
-  'TMPDIR',
-  'TMP',
-  'TEMP',
-  'LANG',
-  'LC_ALL',
-  'LC_CTYPE',
-  'TERM',
-  'NODE_ENV',
-  'COREPACK_HOME',
-  'PNPM_HOME',
-  'YARN_CACHE_FOLDER',
-  'BUN_INSTALL',
-  'PLAYWRIGHT_BROWSERS_PATH',
-];
-
-function isProcessAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function syncRoutesBestEffort(reason) {
-  try {
-    await syncArtifactRoutesToGateway(reason);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.warn(`[AmalgmMCP] Artifact route sync failed (${reason}): ${message}`);
-  }
-}
-
-function replacePort(command, port) {
-  return String(command || '').replace(/\{port\}/g, String(port));
-}
-
-function buildEnv(artifact) {
-  const env = {};
-  for (const key of ARTIFACT_ENV_ALLOWLIST) {
-    if (process.env[key]) env[key] = process.env[key];
-  }
-
-  return {
-    ...env,
-    PORT: String(artifact.port),
-    AMALGM_ARTIFACT_ID: artifact.id,
-    AMALGM_ARTIFACT_REF: artifact.artifactRef,
-    AMALGM_ARTIFACT_URL: artifact.publicUrl,
-    AMALGM_CHAT_SERVER_URL: `http://127.0.0.1:${runtimePort('chat-server')}`,
-    AMALGM_MCP_URL: `http://127.0.0.1:${runtimePort('amalgm-mcp')}`,
-  };
-}
-
-function runCommand(command, cwd, env, timeoutMs = 10 * 60 * 1000) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, {
-      cwd,
-      env,
-      shell: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      windowsHide: true,
-    });
-    let output = '';
-    const timer = setTimeout(() => {
-      try { child.kill('SIGTERM'); } catch {}
-      reject(new Error(`Command timed out after ${Math.round(timeoutMs / 1000)}s`));
-    }, timeoutMs);
-
-    const append = (chunk) => {
-      output += chunk.toString();
-      if (output.length > 12_000) output = output.slice(-12_000);
-    };
-    child.stdout?.on('data', append);
-    child.stderr?.on('data', append);
-    child.on('error', (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-    child.on('exit', (code) => {
-      clearTimeout(timer);
-      if (code === 0) {
-        resolve(output);
-      } else {
-        reject(new Error(output.trim() || `Command exited with code ${code}`));
-      }
-    });
-  });
-}
-
-async function runBuild(artifact) {
-  if (!artifact.buildCommand) return;
-  updateArtifactMeta(artifact.id, { status: 'building', error: null });
-  const command = replacePort(artifact.buildCommand, artifact.port);
-  await runCommand(command, artifact.cwd, buildEnv(artifact));
-}
-
-function startArtifactProcess(artifact) {
-  if (!artifact.startCommand) throw new Error('startCommand is required');
-  if (!fs.existsSync(artifact.cwd)) throw new Error(`Artifact cwd does not exist: ${artifact.cwd}`);
-
-  const command = replacePort(artifact.startCommand, artifact.port);
-  const child = spawn(command, {
-    cwd: artifact.cwd,
-    env: buildEnv(artifact),
-    shell: true,
-    detached: process.platform !== 'win32',
-    stdio: ['ignore', 'pipe', 'pipe'],
-    windowsHide: true,
-  });
-
-  running.set(artifact.id, child);
-  child.unref();
-  child.stdout?.on('data', (chunk) => {
-    console.log(`[Artifact:${artifact.id}] ${chunk.toString().trim()}`);
-  });
-  child.stderr?.on('data', (chunk) => {
-    console.error(`[Artifact:${artifact.id}] ${chunk.toString().trim()}`);
-  });
-  child.on('exit', (code) => {
-    const activeChild = running.get(artifact.id);
-    if (activeChild && activeChild !== child) return;
-    running.delete(artifact.id);
-    const wasStopping = stopping.has(artifact.id);
-    stopping.delete(artifact.id);
-    if (wasStopping) return;
-
-    const current = getArtifact(artifact.id);
-    if (!current) return;
-
-    if (current.desiredState === 'running' && current.keepAlive !== false) {
-      updateArtifactMeta(artifact.id, {
-        status: 'restarting',
-        pid: null,
-        error: code === 0 ? null : `Process exited with code ${code}`,
-      });
-      void syncRoutesBestEffort(`exit:${artifact.id}`);
-      const timer = setTimeout(() => {
-        restartTimers.delete(artifact.id);
-        startArtifact(artifact.id).catch((err) => {
-          updateArtifactMeta(artifact.id, { status: 'error', error: err.message, pid: null });
-        });
-      }, 2000);
-      restartTimers.set(artifact.id, timer);
-      return;
-    }
-
-    updateArtifactMeta(artifact.id, {
-      status: code === 0 ? 'stopped' : 'error',
-      pid: null,
-      error: code === 0 ? null : `Process exited with code ${code}`,
-    });
-    void syncRoutesBestEffort(`exit:${artifact.id}`);
-  });
-
-  return child;
-}
-
-async function startArtifact(artifactId) {
-  const artifact = getArtifact(artifactId);
-  if (!artifact) throw new Error(`Artifact not found: ${artifactId}`);
-  const existingTimer = restartTimers.get(artifactId);
-  if (existingTimer) clearTimeout(existingTimer);
-  restartTimers.delete(artifactId);
-
-  if (running.has(artifactId)) {
-    const current = updateArtifactMeta(artifact.id, {
-      desiredState: 'running',
-      status: 'running',
-      error: null,
-    });
-    await syncRoutesBestEffort(`start:${artifactId}`);
-    return current;
-  }
-
-  if (artifact.pid && isProcessAlive(artifact.pid)) {
-    const current = updateArtifactMeta(artifact.id, {
-      desiredState: 'running',
-      status: 'running',
-      error: null,
-    });
-    await syncRoutesBestEffort(`start:${artifactId}`);
-    return current;
-  }
-
-  if (artifact.pid && !isProcessAlive(artifact.pid)) {
-    updateArtifactMeta(artifact.id, { pid: null });
-  }
-
-  const child = startArtifactProcess(artifact);
-  const current = updateArtifactMeta(artifact.id, {
-    desiredState: 'running',
-    status: 'running',
-    pid: child.pid,
-    error: null,
-    lastStartedAt: new Date().toISOString(),
-  });
-  await syncRoutesBestEffort(`start:${artifactId}`);
-  return current;
-}
-
-async function stopArtifact(artifactId, options = {}) {
-  const artifact = getArtifact(artifactId);
-  if (!artifact) throw new Error(`Artifact not found: ${artifactId}`);
-
-  const timer = restartTimers.get(artifactId);
-  if (timer) clearTimeout(timer);
-  restartTimers.delete(artifactId);
-  stopping.add(artifactId);
-
-  const child = running.get(artifactId);
-  if (child?.pid) {
-    try { process.kill(-child.pid, 'SIGTERM'); } catch {}
-    try { child.kill('SIGTERM'); } catch {}
-  } else if (artifact.pid) {
-    try { process.kill(artifact.pid, 'SIGTERM'); } catch {}
-  }
-  running.delete(artifactId);
-
-  setTimeout(() => stopping.delete(artifactId), 1000);
-  const current = updateArtifactMeta(artifactId, {
-    desiredState: options.desiredState || 'stopped',
-    status: 'stopped',
-    pid: null,
-  });
-  await syncRoutesBestEffort(`stop:${artifactId}`);
-  return current;
-}
-
-async function deleteArtifact(artifactId) {
-  const artifact = getArtifact(artifactId);
-  if (!artifact) throw new Error(`Artifact not found: ${artifactId}`);
-
-  const timer = restartTimers.get(artifactId);
-  if (timer) clearTimeout(timer);
-  restartTimers.delete(artifactId);
-
-  await stopArtifact(artifactId, { desiredState: 'stopped' }).catch(() => {});
-
-  const data = loadArtifacts();
-  data.artifacts = data.artifacts.filter((item) => item.id !== artifactId);
-  saveArtifacts(data);
-
-  stopping.delete(artifactId);
-  running.delete(artifactId);
-  await syncRoutesBestEffort(`delete:${artifactId}`);
-
-  return artifact;
-}
-
-async function registerArtifact(input) {
-  const name = String(input.name || '').trim() || 'Artifact';
-  const cwd = path.resolve(input.cwd || input.root_dir || DEFAULT_CWD);
-  const startCommand = String(input.start_command || input.startCommand || '').trim();
-  if (!startCommand) throw new Error('start_command is required');
-  if (!fs.existsSync(cwd)) throw new Error(`cwd does not exist: ${cwd}`);
-
-  const port = allocatePort(input.port);
-  if (!port) throw new Error('No valid artifact port available');
-
-  const artifactRef = allocateUniqueArtifactRef();
-  const now = new Date().toISOString();
-  const artifact = {
-    id: input.id || cryptoRandomId(),
-    kind: 'artifact',
-    name,
-    description: input.description || '',
-    cwd,
-    port,
-    buildCommand: input.build_command || input.buildCommand || null,
-    startCommand,
-    artifactRef,
-    artifact_ref: artifactRef,
-    publicUrl: publicUrlForRef(artifactRef),
-    dnsConnected: input.connect_dns !== false,
-    autostart: input.autostart !== false,
-    keepAlive: input.keep_alive !== false,
-    desiredState: 'running',
-    status: 'registered',
-    pid: null,
-    createdAt: now,
-    updatedAt: now,
-    lastStartedAt: null,
-    lastDeployedAt: null,
-    error: null,
-  };
-
-  const data = loadArtifacts();
-  data.artifacts.push(artifact);
-  saveArtifacts(data);
-  activeMemory.ensureConstructMemory({
-    type: 'artifact',
-    id: artifact.id,
-    name: artifact.name,
-    projectPath: artifact.cwd,
-  }, { source: 'artifact:register' });
-
-  if (artifact.buildCommand) await runBuild(artifact);
-  await startArtifact(artifact.id);
-  const deployed = updateArtifactMeta(artifact.id, { lastDeployedAt: new Date().toISOString() });
-  activeMemory.ensureConstructMemory({
-    type: 'artifact',
-    id: deployed.id,
-    name: deployed.name,
-    projectPath: deployed.cwd,
-  }, { source: 'artifact:deploy' });
-  return deployed;
-}
-
-async function redeployArtifact(artifactId, updates = {}) {
-  let artifact = getArtifact(artifactId);
-  if (!artifact) throw new Error(`Artifact not found: ${artifactId}`);
-
-  const patch = {};
-  if (updates.cwd || updates.root_dir) patch.cwd = path.resolve(updates.cwd || updates.root_dir);
-  if (updates.port !== undefined) {
-    const parsed = Number(updates.port);
-    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
-      throw new Error('port must be between 1 and 65535');
-    }
-    patch.port = parsed;
-  }
-  if (updates.build_command !== undefined) patch.buildCommand = updates.build_command || null;
-  if (updates.start_command !== undefined) patch.startCommand = updates.start_command;
-  if (updates.keep_alive !== undefined) patch.keepAlive = updates.keep_alive !== false;
-  if (updates.autostart !== undefined) patch.autostart = updates.autostart !== false;
-  if (Object.keys(patch).length > 0) artifact = updateArtifactMeta(artifactId, patch);
-  activeMemory.ensureConstructMemory({
-    type: 'artifact',
-    id: artifact.id,
-    name: artifact.name,
-    projectPath: artifact.cwd,
-  }, { source: 'artifact:update' });
-
-  if (!artifact.startCommand) throw new Error('startCommand is required');
-  if (!fs.existsSync(artifact.cwd)) throw new Error(`cwd does not exist: ${artifact.cwd}`);
-
-  if (artifact.buildCommand) await runBuild(artifact);
-  await stopArtifact(artifactId, { desiredState: 'running' });
-  await startArtifact(artifactId);
-  const deployed = updateArtifactMeta(artifactId, { lastDeployedAt: new Date().toISOString() });
-  activeMemory.ensureConstructMemory({
-    type: 'artifact',
-    id: deployed.id,
-    name: deployed.name,
-    projectPath: deployed.cwd,
-  }, { source: 'artifact:deploy' });
-  return deployed;
-}
-
-function cryptoRandomId() {
-  return `artifact-${Math.random().toString(36).slice(2, 8)}${Date.now().toString(36).slice(-4)}`;
-}
-
-async function connectDns(artifactId) {
-  const artifact = getArtifact(artifactId);
-  if (!artifact) throw new Error(`Artifact not found: ${artifactId}`);
-  const current = updateArtifactMeta(artifactId, { dnsConnected: true });
-  await syncRoutesBestEffort(`connect-dns:${artifactId}`);
-  return current;
-}
-
-async function disconnectDns(artifactId) {
-  const artifact = getArtifact(artifactId);
-  if (!artifact) throw new Error(`Artifact not found: ${artifactId}`);
-  const current = updateArtifactMeta(artifactId, { dnsConnected: false });
-  await syncRoutesBestEffort(`disconnect-dns:${artifactId}`);
-  return current;
-}
-
-async function startRegisteredArtifacts() {
-  const data = loadArtifacts();
-  await Promise.allSettled(data.artifacts.map(async (artifact) => {
-    if (artifact.pid && !isProcessAlive(artifact.pid)) {
-      updateArtifactMeta(artifact.id, { pid: null });
-    }
-
-    if (artifact.autostart !== false && artifact.desiredState === 'running') {
-      await startArtifact(artifact.id).catch((err) => {
-        updateArtifactMeta(artifact.id, { status: 'error', error: err.message, pid: null });
-      });
-    }
-  }));
-  await syncRoutesBestEffort('boot');
-}
-
-module.exports = {
-  deleteArtifact,
-  connectDns,
-  disconnectDns,
-  redeployArtifact,
-  registerArtifact,
-  runBuild,
-  startArtifact,
-  startRegisteredArtifacts,
-  stopArtifact,
-};