clawmini 0.0.7 → 0.0.9

package/e2e/jobs/cron.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+// Basic CRUD for jobs is covered via lite in agent-jobs.test.ts. This file
+// covers behavior that only emerges through the scheduler/full CLI: firing a
+// scheduled `--at` job, inheriting chat defaults, and CLI-level date parsing.
+
+describe('E2E Cron Tests', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-tmp-cron');
+    await env.setup();
+    await env.init();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('should execute a job and inherit chat default agent and session', async () => {
+    await env.runCli(['agents', 'add', 'cron-exec-agent']);
+    env.updateAgentSettings('cron-exec-agent', {
+      commands: { new: 'echo "executed with $SESSION_ID and msg: $CLAW_CLI_MESSAGE"' },
+    });
+
+    await env.addChat('cron-chat');
+    const { code: codeSetup, stderr: stderrSetup } = await env.runCli([
+      'messages', 'send', 'setup session',
+      '-c', 'cron-chat',
+      '-a', 'cron-exec-agent',
+    ]);
+    if (codeSetup !== 0) console.error(stderrSetup);
+    expect(codeSetup).toBe(0);
+
+    const futureTime = new Date(Date.now() + 2000).toISOString();
+    const { stdout: stdoutAdd, code: codeAdd } = await env.runCli([
+      'jobs', 'add', 'test-exec-job',
+      '-c', 'cron-chat',
+      '--at', futureTime,
+      '--message', 'hello from future',
+    ]);
+    expect(codeAdd).toBe(0);
+    expect(stdoutAdd).toContain("Job 'test-exec-job' created successfully.");
+
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+
+    const { stdout: stdoutHistory } = await env.runCli(['messages', 'tail', '-c', 'cron-chat']);
+    expect(stdoutHistory).toContain('hello from future');
+    // Confirms cron-exec-agent (not default) ran the job.
+    expect(stdoutHistory).toContain('msg: hello from future');
+
+    // One-off --at jobs should be removed from settings after firing.
+    const { stdout: stdoutListAfter } = await env.runCli(['jobs', 'list', '-c', 'cron-chat']);
+    expect(stdoutListAfter).not.toContain('test-exec-job');
+  }, 10000);
+
+  it('should reject jobs with invalid --at date format', async () => {
+    const { stderr, code } = await env.runCli([
+      'jobs', 'add', 'invalid-job',
+      '--at', 'invalid-date',
+    ]);
+    expect(code).not.toBe(0);
+    expect(stderr).toContain("Invalid date format for 'at' schedule: invalid-date");
+  });
+});

package/e2e/jobs/restart.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+// Covers what happens to scheduled jobs when the daemon stops and starts
+// again — a case the other files do not exercise (they keep one daemon up
+// for the whole describe block).
+describe('E2E Job Restart Behavior', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-tmp-jobs-restart');
+    await env.setup();
+    await env.init();
+
+    await env.runCli(['agents', 'add', 'restart-agent']);
+    env.updateAgentSettings('restart-agent', {
+      commands: { new: 'echo "[restart-agent] msg: $CLAW_CLI_MESSAGE"' },
+    });
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('fires overdue --at jobs after the daemon restarts and removes them', async () => {
+    await env.addChat('restart-at-chat');
+    // Pin the chat to restart-agent so the cron firing routes through our
+    // echo command (the job below specifies no agentId and inherits).
+    const setup = await env.runCli([
+      'messages', 'send', 'setup',
+      '-c', 'restart-at-chat',
+      '-a', 'restart-agent',
+    ]);
+    expect(setup.code).toBe(0);
+
+    // Schedule for ~5s out — enough margin to call down() before the
+    // running daemon's scheduler can fire the job.
+    const futureTime = new Date(Date.now() + 5000).toISOString();
+    const add = await env.runCli([
+      'jobs', 'add', 'overdue-job',
+      '-c', 'restart-at-chat',
+      '--at', futureTime,
+      '--message', 'caught up after restart',
+    ]);
+    expect(add.code).toBe(0);
+
+    await env.down();
+
+    // Block past the target time so the job is overdue when the daemon
+    // comes back up.
+    await new Promise((r) => setTimeout(r, 6000));
+
+    await env.up();
+    // Give the cron manager time to detect the overdue job (~100ms scheduling
+    // delay in cron.ts) plus the agent's command execution.
+    await new Promise((r) => setTimeout(r, 3000));
+
+    const { stdout: history } = await env.runCli([
+      'messages', 'tail', '-c', 'restart-at-chat',
+    ]);
+    expect(history).toContain('caught up after restart');
+    expect(history).toContain('msg: caught up after restart');
+
+    const { stdout: jobsList } = await env.runCli([
+      'jobs', 'list', '-c', 'restart-at-chat',
+    ]);
+    expect(jobsList).not.toContain('overdue-job');
+  }, 30000);
+
+  // Documents current behavior: cron/every ticks that elapse while the
+  // daemon is down are silently dropped — the next tick is scheduled, but
+  // missed ones are not backfilled.
+  it('does not backfill cron ticks missed while the daemon was down', async () => {
+    await env.addChat('restart-cron-chat');
+    const setup = await env.runCli([
+      'messages', 'send', 'setup',
+      '-c', 'restart-cron-chat',
+      '-a', 'restart-agent',
+    ]);
+    expect(setup.code).toBe(0);
+
+    // Daily-at-midnight: outside the rare midnight window, the previous
+    // tick is hours in the past and the next tick is hours in the future,
+    // so nothing should fire during the test regardless of restart timing.
+    const add = await env.runCli([
+      'jobs', 'add', 'nightly-job',
+      '-c', 'restart-cron-chat',
+      '--cron', '0 0 * * *',
+      '--message', 'should-not-fire-on-restart',
+    ]);
+    expect(add.code).toBe(0);
+
+    await env.down();
+    await env.up();
+
+    // Give any (unwanted) immediate firing a chance to land before
+    // asserting it didn't happen.
+    await new Promise((r) => setTimeout(r, 3000));
+
+    const { stdout: history } = await env.runCli([
+      'messages', 'tail', '-c', 'restart-cron-chat',
+    ]);
+    expect(history).not.toContain('should-not-fire-on-restart');
+
+    const { stdout: jobsList } = await env.runCli([
+      'jobs', 'list', '-c', 'restart-cron-chat',
+    ]);
+    expect(jobsList).toContain('nightly-job');
+  }, 30000);
+});

package/e2e/policies/approval-session.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  type SystemMessage,
+  policyWith,
+} from '../_helpers/test-environment.js';
+
+// When an agent requests a policy and the user /approves it, the approval must
+// be replayed into the agent's *current* session — not a hard-coded 'default'.
+// The current session may have drifted from the one that created the request
+// (e.g. session-timeout fired or the user ran /new).
+describe('Policy approval runs on the agent\'s current session', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-approval-session');
+    await env.setup();
+    await env.setupSubagentEnv({
+      policies: {
+        'test-cmd': {
+          description: 'A test policy',
+          command: 'echo',
+          args: ['approved-output'],
+        },
+      },
+    });
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('replays the approval into the session recorded in chatSettings.sessions, not "default"', async () => {
+    const chatId = 'chat-approval-session';
+    await env.addChat(chatId, 'debug-agent');
+
+    // Pin the chat's debug-agent session to a known non-'default' id so the
+    // bug (falling back to 'default') is observable. In production this drift
+    // is what happens after session-timeout or /new.
+    env.writeChatSettings(chatId, {
+      defaultAgent: 'debug-agent',
+      sessions: { 'debug-agent': 'pinned-session-xyz' },
+    });
+
+    chat = await env.connect(chatId);
+
+    // Agent requests the policy. This runs in sessionId='pinned-session-xyz'.
+    await env.sendMessage('clawmini-lite.js request test-cmd', {
+      chat: chatId,
+      agent: 'debug-agent',
+    });
+
+    const policy = await chat.waitForMessage(policyWith());
+    const reqId = policy.requestId;
+
+    await env.sendMessage(`/approve ${reqId}`, { chat: chatId });
+
+    // The second 'policy_approved' system message (displayRole='user') is the
+    // one emitted by the re-triggered agent message pipeline. Its sessionId
+    // reflects the session the approval was actually replayed on.
+    const actorNotif = await chat.waitForMessage(
+      (m): m is SystemMessage =>
+        m.role === 'system' && m.event === 'policy_approved' && m.displayRole === 'user'
+    );
+
+    expect(actorNotif.sessionId).toBe('pinned-session-xyz');
+  }, 30000);
+});

package/e2e/policies/auto-create-policies-file.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs';
+import { TestEnvironment } from '../_helpers/test-environment.js';
+
+describe('clawmini up auto-creates policies.json', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-auto-create-policies');
+    await env.setup();
+    // Intentionally omit `policies` so no policies.json is pre-written.
+    await env.setupSubagentEnv();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('creates an empty policies.json during up', () => {
+    const policiesPath = path.resolve(env.e2eDir, '.clawmini/policies.json');
+    expect(fs.existsSync(policiesPath)).toBe(true);
+    expect(JSON.parse(fs.readFileSync(policiesPath, 'utf8'))).toEqual({ policies: {} });
+  });
+
+  it('exposes the built-in run-host policy even though the user never wrote policies.json', async () => {
+    const { stdout, code } = await env.runLite(['requests', 'list']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('- run-host');
+  }, 30000);
+
+  it('allows --help on run-host via lite without approval', async () => {
+    const { stdout, code } = await env.runLite(['request', 'run-host', '--help']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('--command');
+  }, 30000);
+});

package/e2e/policies/builtin-manage-policies.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  type SystemMessage,
+  policyWith,
+  commandMatching
+} from '../_helpers/test-environment.js';
+
+const SCRIPT_REL = '.clawmini/policy-scripts/manage-policies.js';
+
+describe('Built-in manage-policies installation', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-builtin-install');
+    await env.setup();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('init writes the manage-policies script to disk', async () => {
+    const { code, stderr } = await env.init();
+    if (code !== 0) throw new Error(`Init failed: ${stderr}`);
+
+    const scriptPath = path.resolve(env.e2eDir, SCRIPT_REL);
+    expect(fs.existsSync(scriptPath)).toBe(true);
+    const content = fs.readFileSync(scriptPath, 'utf8');
+    expect(content.startsWith('#!')).toBe(true);
+    expect((fs.statSync(scriptPath).mode & 0o111) !== 0).toBe(true);
+  }, 30000);
+
+  it('up refreshes a stale manage-policies script', async () => {
+    const scriptPath = path.resolve(env.e2eDir, SCRIPT_REL);
+    const original = fs.readFileSync(scriptPath, 'utf8');
+
+    fs.writeFileSync(scriptPath, '#!/usr/bin/env node\n// stale\n');
+    expect(fs.readFileSync(scriptPath, 'utf8')).not.toBe(original);
+
+    const { code, stderr } = await env.up();
+    if (code !== 0) throw new Error(`Up failed: ${stderr}`);
+
+    expect(fs.readFileSync(scriptPath, 'utf8')).toBe(original);
+  }, 30000);
+});
+
+describe('Built-in manage-policies E2E', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-builtin-manage-policies');
+    await env.setup();
+    await env.setupSubagentEnv({
+      policies: {}
+    });
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('should allow the agent to add a new policy via manage-policies add', async () => {
+    await env.addChat('chat-add');
+    chat = await env.connect('chat-add');
+
+    await env.sendMessage(
+      'clawmini-lite.js request manage-policies -- add --name npm-install --description "Run npm install" --command "npm install"',
+      {
+        chat: 'chat-add',
+        agent: 'debug-agent',
+      }
+    );
+
+    const policy = await chat.waitForMessage(policyWith());
+    const reqId = policy.requestId;
+
+    await env.sendMessage(`/approve ${reqId}`, { chat: 'chat-add' });
+
+    const actorNotif = await chat.waitForMessage(
+      (m): m is SystemMessage =>
+        m.role === 'system' &&
+        m.event === 'policy_approved' &&
+        m.displayRole === 'user'
+    );
+    expect(actorNotif.content).toContain("Successfully added policy 'npm-install'");
+
+    const policiesPath = path.resolve(env.e2eDir, '.clawmini/policies.json');
+    const policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
+
+    expect(policies.policies['npm-install']).toBeDefined();
+    expect(policies.policies['npm-install'].command).toBe('npm');
+    expect(policies.policies['npm-install'].args).toEqual(['install']);
+  }, 30000);
+
+  it('should disable manage-policies if set to false in policies.json', async () => {
+    const policiesPath = path.resolve(env.e2eDir, '.clawmini/policies.json');
+    const policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
+    policies.policies['manage-policies'] = false;
+    fs.writeFileSync(policiesPath, JSON.stringify(policies, null, 2));
+
+    await env.addChat('chat-disabled');
+    chat = await env.connect('chat-disabled');
+
+    await env.sendMessage(
+      'clawmini-lite.js request manage-policies -- add --name foo --description "bar" --command "baz"',
+      {
+        chat: 'chat-disabled',
+        agent: 'debug-agent',
+      }
+    );
+
+    const reply = await chat.waitForMessage(
+      commandMatching((m) => m.stderr.includes('Policy not found: manage-policies'))
+    );
+
+    expect(reply.stderr).toContain('Policy not found: manage-policies');
+
+    // Disabling the policy must not delete the installed script — the user can
+    // re-enable it later just by removing the `false` entry.
+    const scriptPath = path.resolve(env.e2eDir, SCRIPT_REL);
+    expect(fs.existsSync(scriptPath)).toBe(true);
+  }, 30000);
+});
+
+describe('Built-in manage-policies override', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-builtin-override');
+    await env.setup();
+    await env.setupSubagentEnv({
+      policies: {
+        'manage-policies': {
+          description: 'user-defined override',
+          command: 'echo',
+          args: ['overridden'],
+          allowHelp: true,
+        },
+      },
+    });
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('runs a user-defined manage-policies override instead of the built-in', async () => {
+    await env.addChat('chat-override');
+    const chat = await env.connect('chat-override');
+    try {
+      await env.sendMessage(
+        'clawmini-lite.js request manage-policies -- add --name custom --description "x" --command "echo y"',
+        { chat: 'chat-override', agent: 'debug-agent' }
+      );
+
+      const policy = await chat.waitForMessage(policyWith());
+      const reqId = policy.requestId;
+
+      await env.sendMessage(`/approve ${reqId}`, { chat: 'chat-override' });
+
+      const actorNotif = await chat.waitForMessage(
+        (m): m is SystemMessage =>
+          m.role === 'system' && m.event === 'policy_approved' && m.displayRole === 'user'
+      );
+      // The override sends `echo overridden ...args` so stdout starts with "overridden".
+      expect(actorNotif.content).toContain('overridden');
+      // Built-in success message must NOT appear — the override took effect.
+      expect(actorNotif.content).not.toContain('Successfully added policy');
+
+      // policies.json should be unchanged: the override is `echo`, which never
+      // writes to it, so no `custom` entry should have been added.
+      const policiesPath = path.resolve(env.e2eDir, '.clawmini/policies.json');
+      const policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
+      expect(policies.policies['custom']).toBeUndefined();
+      // And the user override must still be intact.
+      expect(policies.policies['manage-policies']).toMatchObject({
+        command: 'echo',
+        args: ['overridden'],
+      });
+    } finally {
+      await chat.disconnect();
+    }
+  }, 30000);
+});

package/e2e/policies/builtin-run-host.test.ts

@@ -0,0 +1,180 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import path from 'node:path';
+import fs from 'node:fs';
+import {
+  TestEnvironment,
+  type ChatSubscription,
+  type SystemMessage,
+  policyWith,
+  commandMatching,
+} from '../_helpers/test-environment.js';
+
+const RUN_HOST_SCRIPT_REL = '.clawmini/policy-scripts/run-host.js';
+
+describe('Built-in run-host installation', () => {
+  let env: TestEnvironment;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-builtin-run-host-install');
+    await env.setup();
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+
+  it('init writes the run-host script to disk', async () => {
+    const { code, stderr } = await env.init();
+    if (code !== 0) throw new Error(`Init failed: ${stderr}`);
+
+    const scriptPath = path.resolve(env.e2eDir, RUN_HOST_SCRIPT_REL);
+    expect(fs.existsSync(scriptPath)).toBe(true);
+    const content = fs.readFileSync(scriptPath, 'utf8');
+    expect(content.startsWith('#!')).toBe(true);
+    expect((fs.statSync(scriptPath).mode & 0o111) !== 0).toBe(true);
+  }, 30000);
+});
+
+describe('Built-in run-host E2E', () => {
+  let env: TestEnvironment;
+  let chat: ChatSubscription | undefined;
+
+  beforeAll(async () => {
+    env = new TestEnvironment('e2e-builtin-run-host');
+    await env.setup();
+    await env.setupSubagentEnv({
+      policies: {},
+    });
+  }, 30000);
+
+  afterAll(() => env.teardown(), 30000);
+  afterEach(() => env.disconnectAll());
+
+  it('executes a shell command with pipes and && via run-host after approval', async () => {
+    await env.addChat('chat-run');
+    chat = await env.connect('chat-run');
+
+    await env.sendMessage(
+      'clawmini-lite.js request run-host -- --command "echo hello && echo world | tr a-z A-Z"',
+      { chat: 'chat-run', agent: 'debug-agent' }
+    );
+
+    const policy = await chat.waitForMessage(policyWith());
+    const reqId = policy.requestId;
+
+    await env.sendMessage(`/approve ${reqId}`, { chat: 'chat-run' });
+
+    const actorNotif = await chat.waitForMessage(
+      (m): m is SystemMessage =>
+        m.role === 'system' &&
+        m.event === 'policy_approved' &&
+        m.displayRole === 'user'
+    );
+
+    expect(actorNotif.content).toContain('hello');
+    expect(actorNotif.content).toContain('WORLD');
+    expect(actorNotif.content).toContain('Exit Code: 0');
+  }, 30000);
+
+  it('propagates non-zero exit codes from the executed command', async () => {
+    await env.addChat('chat-exit');
+    chat = await env.connect('chat-exit');
+
+    await env.sendMessage(
+      'clawmini-lite.js request run-host -- --command "false"',
+      { chat: 'chat-exit', agent: 'debug-agent' }
+    );
+
+    const policy = await chat.waitForMessage(policyWith());
+    const reqId = policy.requestId;
+
+    await env.sendMessage(`/approve ${reqId}`, { chat: 'chat-exit' });
+
+    const actorNotif = await chat.waitForMessage(
+      (m): m is SystemMessage =>
+        m.role === 'system' &&
+        m.event === 'policy_approved' &&
+        m.displayRole === 'user'
+    );
+
+    expect(actorNotif.content).toContain('Exit Code: 1');
+  }, 30000);
+
+  it('does not auto-approve — request stays pending until the user approves', async () => {
+    await env.addChat('chat-pending');
+    chat = await env.connect('chat-pending');
+
+    await env.sendMessage(
+      'clawmini-lite.js request run-host -- --command "echo should-not-run-yet"',
+      { chat: 'chat-pending', agent: 'debug-agent' }
+    );
+
+    const policy = await chat.waitForMessage(policyWith());
+    expect(policy.status).toBe('pending');
+
+    const approvedEarly = chat.messageBuffer.find(
+      (m): m is SystemMessage =>
+        m.role === 'system' && m.event === 'policy_approved'
+    );
+    expect(approvedEarly).toBeUndefined();
+  }, 30000);
+
+  it('supports --help via lite', async () => {
+    const { stdout, code } = await env.runLite(['request', 'run-host', '--help']);
+    expect(code).toBe(0);
+    expect(stdout).toContain('--command');
+  }, 30000);
+
+  it('truncates large stdout to a saved-file summary', async () => {
+    await env.addChat('chat-long');
+    chat = await env.connect('chat-long');
+
+    await env.sendMessage(
+      'clawmini-lite.js request run-host -- --command "yes a | head -c 600"',
+      { chat: 'chat-long', agent: 'debug-agent' }
+    );
+
+    const policy = await chat.waitForMessage(policyWith());
+    const reqId = policy.requestId;
+
+    await env.sendMessage(`/approve ${reqId}`, { chat: 'chat-long' });
+
+    const actorNotif = await chat.waitForMessage(
+      (m): m is SystemMessage =>
+        m.role === 'system' &&
+        m.event === 'policy_approved' &&
+        m.displayRole === 'user'
+    );
+    expect(actorNotif.content).toMatch(
+      /stdout is 60\d characters, saved to \.\/tmp\/stdout-[a-zA-Z0-9-]+\.txt/
+    );
+    expect(actorNotif.content).not.toContain('a\n'.repeat(300));
+  }, 30000);
+
+  it('rejects requests when run-host is disabled in policies.json', async () => {
+    const policiesPath = path.resolve(env.e2eDir, '.clawmini/policies.json');
+    const policies = JSON.parse(fs.readFileSync(policiesPath, 'utf8'));
+    policies.policies['run-host'] = false;
+    fs.writeFileSync(policiesPath, JSON.stringify(policies, null, 2));
+
+    try {
+      await env.addChat('chat-disabled');
+      chat = await env.connect('chat-disabled');
+
+      await env.sendMessage(
+        'clawmini-lite.js request run-host -- --command "echo nope"',
+        { chat: 'chat-disabled', agent: 'debug-agent' }
+      );
+
+      const reply = await chat.waitForMessage(
+        commandMatching((m) => m.stderr.includes('Policy not found: run-host'))
+      );
+      expect(reply.stderr).toContain('Policy not found: run-host');
+
+      // Disabling the policy must not delete the installed script.
+      const scriptPath = path.resolve(env.e2eDir, RUN_HOST_SCRIPT_REL);
+      expect(fs.existsSync(scriptPath)).toBe(true);
+    } finally {
+      delete policies.policies['run-host'];
+      fs.writeFileSync(policiesPath, JSON.stringify(policies, null, 2));
+    }
+  }, 30000);
+});