Skip to content

nanocoai/nanoclaw / .claude/skills/add-clidash

add-clidash

Unverified

Add clidash — a zero-dependency, read-only web dashboard that derives its tabs and tables at runtime from any CLI that lists resources as JSON. Ships pre-wired for NanoClaw's ncl CLI (agent groups, sessions, channels, users, roles), plus message-activity charts, a log tail, and a read-only file viewer for group skills/CLAUDE.md/profiles.

FileKindSize
REMOVE.mdmarkdown544 B
SKILL.mdskill md6.3 KB
add/tools/clidash/README.mdmarkdown4.0 KB
add/tools/clidash/activity.jsscript3.5 KB
add/tools/clidash/clidash.config.example.jsonconfig3.3 KB
add/tools/clidash/docs.jsscript3.7 KB
add/tools/clidash/logs.jsscript667 B
add/tools/clidash/package.jsonmanifest347 B
add/tools/clidash/parsers.jsscript3.3 KB
add/tools/clidash/public/app.jsscript32.6 KB
add/tools/clidash/public/apple-touch-icon.pngbinary5.3 KB
add/tools/clidash/public/favicon.icobinary547 B
add/tools/clidash/public/favicon.svgother570 B
add/tools/clidash/public/icon-192.pngbinary6.5 KB
add/tools/clidash/public/icon-512.pngbinary18.5 KB
add/tools/clidash/public/index.htmlother1.9 KB
add/tools/clidash/public/md.jsscript2.7 KB
add/tools/clidash/public/site.webmanifestother298 B
add/tools/clidash/public/style.cssother18.0 KB
add/tools/clidash/server.jsscript17.2 KB
add/tools/clidash/test/activity-server.test.jsscript2.3 KB
add/tools/clidash/test/activity.test.jsscript3.8 KB
add/tools/clidash/test/cmd.test.jsscript3.4 KB
add/tools/clidash/test/css.test.jsscript991 B
add/tools/clidash/test/docs-server.test.jsscript4.0 KB
add/tools/clidash/test/docs.test.jsscript4.4 KB
add/tools/clidash/test/fixtures/ncl-help.txtmarkdown4.1 KB
add/tools/clidash/test/fixtures/stub-cli.jsscript1.8 KB
add/tools/clidash/test/help.test.jsscript2.2 KB
add/tools/clidash/test/logs.test.jsscript2.9 KB
add/tools/clidash/test/md.test.jsscript2.9 KB
add/tools/clidash/test/ncl-overview.test.jsscript3.5 KB
add/tools/clidash/test/parsers.test.jsscript4.0 KB
add/tools/clidash/test/server.test.jsscript8.9 KB
add/tools/clidash/test/smoke.shexecutablescript747 B
add/tools/clidash/views/ncl-overview.jsscript1.9 KB

add/tools/clidash/test/server.test.js

View on GitHub
import { test, before, after } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { createApp } from '../server.js';

const STUB = fileURLToPath(new URL('./fixtures/stub-cli.js', import.meta.url));
const tmp = mkdtempSync(join(tmpdir(), 'clidash-test-'));

function stubCli(extra = {}) {
  return {
    bin: process.execPath,
    discover: { args: [STUB, 'help'], parser: 'ncl-help' },
    list: [STUB, '{resource}', 'list', '--json'],
    output: 'json',
    unwrap: 'data',
    ...extra,
  };
}

function makeConfig(clis, extra = {}) {
  return { port: 0, bind: '127.0.0.1', execTimeoutMs: 2000, refreshSeconds: 10, clis, ...extra };
}

async function withServer(config, fn) {
  const server = createApp(config);
  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
  const base = `http://127.0.0.1:${server.address().port}`;
  try {
    return await fn(base);
  } finally {
    await new Promise((resolve) => server.close(resolve));
  }
}

after(() => rmSync(tmp, { recursive: true, force: true }));

// ----------------------------------------------------------------- /api/clis

test('/api/clis: lists configured CLIs with discovered resources', async () => {
  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
    const res = await fetch(`${base}/api/clis`);
    assert.equal(res.status, 200);
    const body = await res.json();
    assert.equal(body.clis.length, 1);
    assert.equal(body.clis[0].name, 'stub');
    assert.equal(body.clis[0].refreshSeconds, 10);
    const names = body.clis[0].resources.map((r) => r.name);
    assert.ok(names.includes('sessions'));
    assert.ok(names.includes('groups'));
    assert.equal(names.length, 11);
  });
});

test('/api/clis: static resource list needs no discovery', async () => {
  const cli = stubCli({ resources: ['alpha', 'beta'] });
  delete cli.discover;
  await withServer(makeConfig({ stub: cli }), async (base) => {
    const body = await (await fetch(`${base}/api/clis`)).json();
    assert.deepEqual(body.clis[0].resources.map((r) => r.name), ['alpha', 'beta']);
  });
});

test('/api/clis: discovery failure reports a loud error', async () => {
  const cli = stubCli();
  cli.env = { STUB_FAIL: '1' };
  await withServer(makeConfig({ stub: cli }), async (base) => {
    const body = await (await fetch(`${base}/api/clis`)).json();
    assert.equal(body.clis[0].resources.length, 0);
    assert.match(body.clis[0].error, /boom/);
  });
});

// ------------------------------------------------------------ /api/r/cli/res

test('/api/r: returns unwrapped rows with fetchedAt', async () => {
  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
    const res = await fetch(`${base}/api/r/stub/sessions`);
    assert.equal(res.status, 200);
    const body = await res.json();
    assert.equal(body.ok, true);
    assert.deepEqual(body.rows.map((r) => r.id), ['sessions-1', 'sessions-2']);
    assert.ok(body.fetchedAt);
  });
});

test('/api/r: rejects a resource not in the discovered set without exec', async () => {
  const countFile = join(tmp, 'count-reject.txt');
  const cli = stubCli();
  cli.env = { STUB_COUNT_FILE: countFile };
  await withServer(makeConfig({ stub: cli }), async (base) => {
    const res = await fetch(`${base}/api/r/stub/evil%20--rm`);
    assert.equal(res.status, 404);
    const body = await res.json();
    assert.equal(body.ok, false);
    // only the discovery exec ran — never a list exec for the bogus resource
    const calls = readFileSync(countFile, 'utf8').trim().split('\n');
    assert.deepEqual(calls, ['help']);
  });
});

test('/api/r: unknown cli → 404', async () => {
  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
    const res = await fetch(`${base}/api/r/nope/sessions`);
    assert.equal(res.status, 404);
  });
});

test('/api/r: jsonlines CLI with static resources works', async () => {
  const cli = {
    bin: process.execPath,
    resources: ['ps'],
    list: [STUB, '{resource}'],
    output: 'jsonlines',
    env: { STUB_JSONLINES: '1' },
  };
  await withServer(makeConfig({ docker: cli }), async (base) => {
    const body = await (await fetch(`${base}/api/r/docker/ps`)).json();
    assert.equal(body.ok, true);
    assert.deepEqual(body.rows.map((r) => r.id), ['ps-1', 'ps-2']);
  });
});

test('/api/r: exec failure returns ok:false with stderr', async () => {
  const cli = stubCli({ resources: ['sessions'] });
  delete cli.discover;
  cli.env = { STUB_FAIL: '1' };
  await withServer(makeConfig({ stub: cli }), async (base) => {
    const res = await fetch(`${base}/api/r/stub/sessions`);
    assert.equal(res.status, 502);
    const body = await res.json();
    assert.equal(body.ok, false);
    assert.match(body.error, /boom: socket down/);
  });
});

test('/api/r: exec timeout returns ok:false naming the resource', async () => {
  const cli = stubCli({ resources: ['sessions'] });
  delete cli.discover;
  cli.env = { STUB_SLEEP_MS: '5000' };
  await withServer(makeConfig({ stub: cli }, { execTimeoutMs: 200 }), async (base) => {
    const body = await (await fetch(`${base}/api/r/stub/sessions`)).json();
    assert.equal(body.ok, false);
    assert.match(body.error, /sessions/);
    assert.match(body.error, /timed out/i);
  });
});

test('/api/r: malformed CLI output returns the raw output', async () => {
  const cli = stubCli({ resources: ['sessions'] });
  delete cli.discover;
  cli.env = { STUB_RAW: 'this is not json' };
  await withServer(makeConfig({ stub: cli }), async (base) => {
    const body = await (await fetch(`${base}/api/r/stub/sessions`)).json();
    assert.equal(body.ok, false);
    assert.match(body.raw, /this is not json/);
  });
});

test('/api/r: concurrent requests for the same resource coalesce into one exec', async () => {
  const countFile = join(tmp, 'count-coalesce.txt');
  const cli = stubCli({ resources: ['sessions'] });
  delete cli.discover;
  cli.env = { STUB_COUNT_FILE: countFile, STUB_SLEEP_MS: '150' };
  await withServer(makeConfig({ stub: cli }), async (base) => {
    const bodies = await Promise.all(
      Array.from({ length: 5 }, () => fetch(`${base}/api/r/stub/sessions`).then((r) => r.json())),
    );
    for (const body of bodies) assert.equal(body.ok, true);
    const calls = readFileSync(countFile, 'utf8').trim().split('\n');
    assert.equal(calls.length, 1);
  });
});

// ------------------------------------------------------------- /api/view

test('/api/view: runs a view plugin with a bound fetch helper', async () => {
  const viewsDir = join(tmp, 'views');
  writeFileSync(join(viewsDir, '..', 'placeholder'), ''); // ensure tmp exists
  const { mkdirSync } = await import('node:fs');
  mkdirSync(viewsDir, { recursive: true });
  writeFileSync(
    join(viewsDir, 'stub-overview.js'),
    'export default async function ({ fetch }) {\n' +
    '  const rows = await fetch("sessions");\n' +
    '  return { count: rows.length, first: rows[0].id };\n' +
    '}\n',
  );
  await withServer(makeConfig({ stub: stubCli() }, { viewsDir }), async (base) => {
    const res = await fetch(`${base}/api/view/stub/overview`);
    assert.equal(res.status, 200);
    const body = await res.json();
    assert.equal(body.ok, true);
    assert.deepEqual(body.result, { count: 2, first: 'sessions-1' });
  });
});

test('/api/view: missing view → 404; bad view name → 404', async () => {
  await withServer(makeConfig({ stub: stubCli() }, { viewsDir: join(tmp, 'views') }), async (base) => {
    assert.equal((await fetch(`${base}/api/view/stub/nope`)).status, 404);
    assert.equal((await fetch(`${base}/api/view/stub/..%2F..%2Fserver`)).status, 404);
  });
});

// ------------------------------------------------------------- static files

test('GET /: serves the dashboard index.html', async () => {
  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
    const res = await fetch(`${base}/`);
    assert.equal(res.status, 200);
    assert.match(res.headers.get('content-type'), /text\/html/);
    assert.match(await res.text(), /clidash/i);
  });
});

test('static: path traversal outside public/ is rejected', async () => {
  await withServer(makeConfig({ stub: stubCli() }), async (base) => {
    const res = await fetch(`${base}/..%2Fserver.js`);
    assert.notEqual(res.status, 200);
  });
});

test('/api/r: {resource} substitutes inside a larger argv string (ssh-remote pattern)', async () => {
  const cli = {
    bin: process.execPath,
    resources: ['sessions'],
    list: [STUB, 'wrapped-{resource}-arg', 'list'],
    output: 'json',
    unwrap: 'data',
    env: { STUB_COUNT_FILE: join(tmp, 'count-embed.txt') },
  };
  await withServer(makeConfig({ stub: cli }), async (base) => {
    const body = await (await fetch(`${base}/api/r/stub/sessions`)).json();
    assert.equal(body.ok, true);
    const calls = readFileSync(join(tmp, 'count-embed.txt'), 'utf8').trim();
    assert.equal(calls, 'wrapped-sessions-arg list');
  });
});
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall