@losclaws/cli 0.1.2 → 0.1.4

package/test/acp-runtime.test.js

@@ -0,0 +1,264 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { loadConfig } from '../src/config.js';
+import {
+  buildTaskPrompt,
+  resolveAcpRuntime,
+  resolveServerAcpDescriptor,
+  runWorkshopAcpTask,
+} from '../src/acp-runtime.js';
+
+test('resolveServerAcpDescriptor reads the server-composed task.acp', () => {
+  const descriptor = resolveServerAcpDescriptor({
+    acp: { key: 'opencode', command: 'opencode', args: ['acp'] },
+  });
+  assert.deepEqual(descriptor, { key: 'opencode', command: 'opencode', args: ['acp'] });
+});
+
+test('resolveAcpRuntime builds a runtime from task.acp', () => {
+  const resolved = resolveAcpRuntime({
+    task: { acp: { key: 'opencode', command: 'opencode', args: ['acp'], model: 'gpt-5.4' } },
+    options: {},
+  });
+  assert.equal(resolved.name, 'opencode');
+  assert.equal(resolved.runtime.command, 'opencode');
+  assert.deepEqual(resolved.runtime.args, ['acp']);
+  assert.equal(resolved.runtime.model, 'gpt-5.4');
+  assert.equal(resolved.source, 'server');
+});
+
+test('resolveAcpRuntime throws when the server returns no coder runtime', () => {
+  assert.throws(() => resolveAcpRuntime({ task: {}, options: {} }), /no coder runtime/);
+});
+
+test('buildTaskPrompt includes artifact and skill disclosure', () => {
+  const result = buildTaskPrompt({
+    role: 'worker',
+    task: {
+      id: 'tsk_123',
+      title: 'Write docs',
+      description: 'Update the project guide.',
+      inputArtifacts: [{ id: 'art_1' }],
+    },
+    localState: {
+      rootPath: '/repo',
+      artifacts: [
+        { id: 'art_1', relativePath: 'artifacts/project/guide.md' },
+      ],
+      skills: [
+        { role: 'worker', path: 'skills/worker/docs-skill' },
+      ],
+    },
+  });
+
+  assert.match(result.prompt, /Task title: Write docs/);
+  assert.match(result.prompt, /artifacts\/project\/guide.md/);
+  assert.match(result.prompt, /skills\/worker\/docs-skill/);
+});
+
+test('buildTaskPrompt appends operator instructions only when provided', () => {
+  const withMessage = buildTaskPrompt({
+    role: 'worker',
+    task: {
+      id: 'tsk_123',
+      title: 'Write docs',
+      description: 'Update the project guide.',
+    },
+    localState: {
+      rootPath: '/repo',
+      artifacts: [],
+      skills: [],
+    },
+    extraMessage: 'Please keep the wording concise.',
+  });
+  const withoutMessage = buildTaskPrompt({
+    role: 'worker',
+    task: {
+      id: 'tsk_123',
+      title: 'Write docs',
+      description: 'Update the project guide.',
+    },
+    localState: {
+      rootPath: '/repo',
+      artifacts: [],
+      skills: [],
+    },
+  });
+
+  assert.match(withMessage.prompt, /Additional operator instructions:\nPlease keep the wording concise\./);
+  assert.doesNotMatch(withoutMessage.prompt, /Additional operator instructions:/);
+});
+
+test('runWorkshopAcpTask executes a real ACP prompt against a local runtime mapping', async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'losclaws-acp-run-'));
+  const metaRoot = path.join(tempRoot, '.losclaws');
+  await fs.mkdir(path.join(tempRoot, 'artifacts', 'project'), { recursive: true });
+  await fs.mkdir(path.join(tempRoot, 'skills', 'worker', 'docs-skill'), { recursive: true });
+  await fs.mkdir(metaRoot, { recursive: true });
+  await fs.writeFile(path.join(tempRoot, 'artifacts', 'project', 'guide.md'), 'hello', 'utf8');
+  await fs.writeFile(
+    path.join(metaRoot, 'state.json'),
+    `${JSON.stringify(
+      {
+        version: 1,
+        rootType: 'project',
+        rootPath: tempRoot,
+        role: 'worker',
+        workspace: { id: 'wrk_1', name: 'Workspace', slug: 'workspace', version: 1 },
+        project: { id: 'prj_1', name: 'Project', slug: 'project', version: 1 },
+        artifacts: [
+          {
+            id: 'art_1',
+            scope: 'project',
+            relativePath: 'artifacts/project/guide.md',
+            contentKind: 'text',
+            mimeType: 'text/plain',
+            lastSyncedHash: 'hash',
+            remoteRevisionNo: 1,
+            remoteVersion: 1,
+          },
+        ],
+        skills: [
+          {
+            name: 'docs-skill',
+            role: 'worker',
+            path: 'skills/worker/docs-skill',
+            source: 'bundled',
+            revision: 'bundled',
+          },
+        ],
+      },
+      null,
+      2,
+    )}\n`,
+    'utf8',
+  );
+
+  const configPath = path.join(tempRoot, 'config.json');
+  const state = await loadConfig(configPath);
+  const fixturePath = fileURLToPath(new URL('../testdata/mock-acp-agent.js', import.meta.url));
+
+  const worklogs = [];
+  const requestWorkshop = async ({ method, path: requestPath, body }) => {
+    if (requestPath === '/api/v1/tasks/tsk_123' && (!method || method === 'GET')) {
+      return {
+        task: {
+          id: 'tsk_123',
+          title: 'Write docs',
+          description: 'Update the project guide.',
+          assigneeRole: 'worker',
+          version: 4,
+          acp: {
+            key: 'mock-agent',
+            command: process.execPath,
+            args: [fixturePath],
+            authMethodId: 'local-auth',
+          },
+          inputArtifacts: [{ id: 'art_1' }],
+        },
+        projectId: 'prj_1',
+      };
+    }
+    if (requestPath === '/api/v1/tasks/tsk_123/worklogs' && method === 'POST') {
+      worklogs.push(body);
+      return { id: `wl_${worklogs.length}`, version: 4 };
+    }
+    throw new Error(`Unexpected request: ${method} ${requestPath}`);
+  };
+
+  const result = await runWorkshopAcpTask({
+    requestWorkshop,
+    state,
+    options: {
+      id: 'tsk_123',
+      root: tempRoot,
+      approvalPolicy: 'auto-allow',
+      closeSession: true,
+    },
+  });
+
+  assert.equal(result.agent.name, 'mock-agent');
+  assert.equal(result.acp.stopReason, 'end_turn');
+  assert.match(result.acp.sessionId, /^sess_/);
+  const logText = await fs.readFile(result.logPath, 'utf8');
+  assert.match(logText, /session_update/);
+  assert.ok(worklogs.length >= 1, 'expected at least one worklog to be recorded');
+  assert.ok(worklogs.every((entry) => typeof entry.updateType === 'string'));
+});
+
+test('runWorkshopAcpTask routes a remote permission request through feedback and back', async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'losclaws-acp-remote-'));
+  const metaRoot = path.join(tempRoot, '.losclaws');
+  await fs.mkdir(metaRoot, { recursive: true });
+  await fs.writeFile(
+    path.join(metaRoot, 'state.json'),
+    `${JSON.stringify({ version: 1, rootType: 'project', rootPath: tempRoot, role: 'worker', artifacts: [], skills: [] }, null, 2)}\n`,
+    'utf8',
+  );
+
+  const configPath = path.join(tempRoot, 'config.json');
+  const state = await loadConfig(configPath);
+  const fixturePath = fileURLToPath(new URL('../testdata/mock-acp-agent.js', import.meta.url));
+
+  let feedbackRequested = null;
+  let feedbackResolved = false;
+  const requestWorkshop = async ({ method, path: requestPath, body }) => {
+    if (requestPath === '/api/v1/tasks/tsk_remote' && (!method || method === 'GET')) {
+      // Once a feedback request exists, report it as submitted so the poll resolves.
+      const feedbackSession = feedbackRequested
+        ? {
+            id: 'fb_1',
+            status: feedbackResolved ? 'submitted' : 'open',
+            kind: 'single_select',
+            version: 1,
+            entries: feedbackResolved ? [{ id: 'e1', response: { optionId: 'allow' }, body: 'Allow' }] : [],
+          }
+        : null;
+      if (feedbackRequested) {
+        feedbackResolved = true;
+      }
+      return {
+        task: {
+          id: 'tsk_remote',
+          title: 'Remote task',
+          version: 7,
+          acp: { key: 'mock-agent', command: process.execPath, args: [fixturePath], authMethodId: 'local-auth' },
+        },
+        feedbackSession,
+      };
+    }
+    if (requestPath === '/api/v1/tasks/tsk_remote/feedback-requests' && method === 'POST') {
+      feedbackRequested = body;
+      return { version: 8 };
+    }
+    if (requestPath === '/api/v1/tasks/tsk_remote/worklogs' && method === 'POST') {
+      return { id: 'wl', version: 8 };
+    }
+    throw new Error(`Unexpected request: ${method} ${requestPath}`);
+  };
+
+  const result = await runWorkshopAcpTask({
+    requestWorkshop,
+    state,
+    options: {
+      id: 'tsk_remote',
+      root: tempRoot,
+      approvalPolicy: 'remote',
+      feedbackTimeout: 20000,
+      closeSession: true,
+      // The mock agent issues a permission request when this env var is set on
+      // the spawned coder; --env is merged into the coder's process environment.
+      env: { MOCK_ACP_REQUEST_PERMISSION: '1' },
+    },
+  });
+
+  assert.equal(result.acp.stopReason, 'end_turn');
+  assert.ok(feedbackRequested, 'expected a feedback request to be posted');
+  assert.equal(feedbackRequested.kind, 'single_select');
+  assert.ok(Array.isArray(feedbackRequested.options) && feedbackRequested.options.length === 2);
+});

package/test/config.test.js

@@ -6,7 +6,12 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
-import { clearedAuthProfile, configForDisplay, resolveRuntime } from '../src/config.js';
+import {
+  clearedAuthProfile,
+  configForDisplay,
+  loadConfig,
+  resolveRuntime,
+} from '../src/config.js';
 
 test('resolveRuntime includes clawworkshop base URL from profile', () => {
   const runtime = resolveRuntime(

package/test/help-docs.test.js

@@ -0,0 +1,50 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+
+import { getHelpText, workshopHelpLines } from '../src/cli.js';
+
+const legacyWorkshopLines = [
+  '  losclaws workshop agents list',
+  '  losclaws workshop agents get --name NAME',
+  '  losclaws workshop agents set --name NAME --command CMD [--title TEXT] [--args JSON|--args-file PATH] [--env JSON|--env-file PATH] [--cwd PATH] [--auth-method-id ID] [--mcp-servers JSON|--mcp-servers-file PATH] [--default-prompt TEXT]',
+  '  losclaws workshop agents delete --name NAME',
+  '  losclaws workshop acp run --id ID [--root PATH] [--agent NAME] [--role worker|reviewer] [--approval-policy interactive|read-only|auto-allow|auto-reject] [--acp-session-id ID] [--workshop-session-id ID] [--workshop-session-version N] [--message TEXT|--message-file PATH] [--close-session] [--dry-run]',
+  '  losclaws workshop sessions update --id ID --expected-version N [--events JSON|--events-file PATH] [--status STATUS] [--log-message TEXT] [--feedback-response JSON]',
+];
+
+test('CLI help reflects current workshop commands and excludes removed ones', () => {
+  const helpText = getHelpText();
+
+  for (const line of workshopHelpLines) {
+    assert.match(helpText, new RegExp(`^${escapeRegExp(line)}$`, 'm'));
+  }
+
+  for (const line of legacyWorkshopLines) {
+    assert.doesNotMatch(helpText, new RegExp(`^${escapeRegExp(line)}$`, 'm'));
+  }
+});
+
+test('README and command reference stay aligned with workshop help', async () => {
+  const readme = await readRelative('../README.md');
+  const commandsReference = await readRelative('../skill/losclaws-cli/references/commands.md');
+
+  for (const line of workshopHelpLines) {
+    const bulletLine = `- \`${line.trim()}\``;
+    assert.match(readme, new RegExp(`^${escapeRegExp(bulletLine)}$`, 'm'));
+    assert.match(commandsReference, new RegExp(`^${escapeRegExp(bulletLine)}$`, 'm'));
+  }
+
+  for (const line of legacyWorkshopLines) {
+    assert.doesNotMatch(readme, new RegExp(escapeRegExp(line.trim())));
+    assert.doesNotMatch(commandsReference, new RegExp(escapeRegExp(line.trim())));
+  }
+});
+
+async function readRelative(relativePath) {
+  return fs.readFile(new URL(relativePath, import.meta.url), 'utf8');
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/test/workshop-local.test.js

@@ -0,0 +1,83 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+
+import { buildArtifactIndex, summarizeIndex } from '../src/workshop-local.js';
+
+test('summarizeIndex returns status counters', () => {
+  const summary = summarizeIndex({
+    entries: [
+      { status: 'clean' },
+      { status: 'clean' },
+      { status: 'modified' },
+      { status: 'missing' },
+      { status: 'untracked' },
+    ],
+  });
+
+  assert.deepEqual(summary, {
+    clean: 2,
+    modified: 1,
+    missing: 1,
+    untracked: 1,
+    total: 5,
+  });
+});
+
+test('buildArtifactIndex detects modified/missing/untracked artifacts', async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'losclaws-workshop-local-test-'));
+  const artifactsDir = path.join(tempRoot, 'artifacts', 'project');
+  await fs.mkdir(artifactsDir, { recursive: true });
+
+  const cleanPath = path.join(artifactsDir, 'clean.txt');
+  const modifiedPath = path.join(artifactsDir, 'modified.txt');
+  const untrackedPath = path.join(artifactsDir, 'untracked.txt');
+  await fs.writeFile(cleanPath, 'clean', 'utf8');
+  await fs.writeFile(modifiedPath, 'new-value', 'utf8');
+  await fs.writeFile(untrackedPath, 'untracked', 'utf8');
+
+  const state = {
+    rootPath: tempRoot,
+    artifacts: [
+      {
+        id: 'art_clean',
+        relativePath: path.join('artifacts', 'project', 'clean.txt'),
+        lastSyncedHash: hashText('clean'),
+        remoteRevisionNo: 1,
+        remoteVersion: 10,
+        contentKind: 'text',
+      },
+      {
+        id: 'art_modified',
+        relativePath: path.join('artifacts', 'project', 'modified.txt'),
+        lastSyncedHash: hashText('old-value'),
+        remoteRevisionNo: 2,
+        remoteVersion: 20,
+        contentKind: 'text',
+      },
+      {
+        id: 'art_missing',
+        relativePath: path.join('artifacts', 'project', 'missing.txt'),
+        lastSyncedHash: hashText('missing'),
+        remoteRevisionNo: 3,
+        remoteVersion: 30,
+        contentKind: 'text',
+      },
+    ],
+  };
+
+  const index = await buildArtifactIndex(state);
+  const byPath = new Map(index.entries.map((entry) => [entry.relativePath.replaceAll('\\', '/'), entry]));
+
+  assert.equal(byPath.get('artifacts/project/clean.txt').status, 'clean');
+  assert.equal(byPath.get('artifacts/project/modified.txt').status, 'modified');
+  assert.equal(byPath.get('artifacts/project/missing.txt').status, 'missing');
+  assert.equal(byPath.get('artifacts/project/untracked.txt').status, 'untracked');
+});
+
+function hashText(value) {
+  return createHash('sha256').update(Buffer.from(value, 'utf8')).digest('hex');
+}

package/testdata/mock-acp-agent.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+import { Readable, Writable } from 'node:stream';
+import * as acp from '@agentclientprotocol/sdk';
+
+class MockAgent {
+  constructor(connection) {
+    this.connection = connection;
+    this.sessions = new Map();
+  }
+
+  async initialize() {
+    return {
+      protocolVersion: acp.PROTOCOL_VERSION,
+      agentCapabilities: {
+        loadSession: true,
+        sessionCapabilities: {
+          close: {},
+          resume: {},
+        },
+      },
+      authMethods: [
+        {
+          id: 'local-auth',
+          name: 'Local auth',
+          description: 'Mock authentication method',
+        },
+      ],
+      agentInfo: {
+        name: 'mock-acp-agent',
+        title: 'Mock ACP Agent',
+        version: '1.0.0',
+      },
+    };
+  }
+
+  async authenticate() {
+    return {};
+  }
+
+  async newSession() {
+    const sessionId = `sess_${Math.random().toString(16).slice(2)}`;
+    this.sessions.set(sessionId, true);
+    return { sessionId };
+  }
+
+  async loadSession(params) {
+    this.sessions.set(params.sessionId, true);
+    return {};
+  }
+
+  async resumeSession(params) {
+    this.sessions.set(params.sessionId, true);
+    return {};
+  }
+
+  async closeSession() {
+    return {};
+  }
+
+  async prompt(params) {
+    const sessionId = params.sessionId;
+
+    // Reasoning / plan / tool-call surface so the bridge maps several update types.
+    await this.connection.sessionUpdate({
+      sessionId,
+      update: {
+        sessionUpdate: 'agent_thought_chunk',
+        content: { type: 'text', text: 'Planning the work.' },
+      },
+    });
+    await this.connection.sessionUpdate({
+      sessionId,
+      update: {
+        sessionUpdate: 'plan',
+        entries: [
+          { content: 'Read the task', status: 'completed', priority: 'high' },
+          { content: 'Make the change', status: 'in_progress', priority: 'high' },
+        ],
+      },
+    });
+    await this.connection.sessionUpdate({
+      sessionId,
+      update: {
+        sessionUpdate: 'tool_call',
+        toolCallId: 'call_1',
+        title: 'Edit guide.md',
+        kind: 'edit',
+        status: 'in_progress',
+      },
+    });
+
+    // Optionally exercise the human-in-the-loop permission round-trip.
+    if (process.env.MOCK_ACP_REQUEST_PERMISSION === '1') {
+      const decision = await this.connection.requestPermission({
+        sessionId,
+        toolCall: { toolCallId: 'call_1', title: 'Apply the edit to guide.md', kind: 'edit' },
+        options: [
+          { optionId: 'allow', name: 'Allow', kind: 'allow_once' },
+          { optionId: 'deny', name: 'Deny', kind: 'reject_once' },
+        ],
+      });
+      await this.connection.sessionUpdate({
+        sessionId,
+        update: {
+          sessionUpdate: 'agent_message_chunk',
+          content: { type: 'text', text: `permission outcome: ${JSON.stringify(decision.outcome)}` },
+        },
+      });
+    }
+
+    await this.connection.sessionUpdate({
+      sessionId,
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: {
+          type: 'text',
+          text: `mock-agent received: ${params.prompt[0].text.slice(0, 40)}`,
+        },
+      },
+    });
+
+    return {
+      stopReason: 'end_turn',
+    };
+  }
+
+  async cancel() {}
+}
+
+const stream = acp.ndJsonStream(
+  Writable.toWeb(process.stdout),
+  Readable.toWeb(process.stdin),
+);
+new acp.AgentSideConnection((connection) => new MockAgent(connection), stream);