@accomplish_ai/agent-core 0.2.0 → 0.2.2

package/mcp-tools/dev-browser/server.cjs

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * Cross-platform dev-browser server launcher.
+ * Replaces server.sh for Windows compatibility.
+ *
+ * This script uses the local tsx binary directly instead of npx to avoid
+ * issues with path resolution when running from the packaged Electron app.
+ */
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const skillDir = __dirname;
+const isWindows = process.platform === 'win32';
+
+// Parse command line arguments
+const headless = process.argv.includes('--headless');
+
+// Logging helper - logs to stderr so it doesn't interfere with stdio inheritance
+function log(...args) {
+  const timestamp = new Date().toISOString();
+  console.error(`[dev-browser server.cjs ${timestamp}]`, ...args);
+}
+
+log('Starting dev-browser server launcher...');
+log('  skillDir:', skillDir);
+log('  isWindows:', isWindows);
+log('  headless:', headless);
+log('  NODE_BIN_PATH:', process.env.NODE_BIN_PATH || '(not set)');
+log('  PATH (first 500 chars):', (process.env.PATH || '').substring(0, 500));
+
+// Find the node executable
+let nodeExe = 'node';
+if (process.env.NODE_BIN_PATH) {
+  const bundledNode = path.join(process.env.NODE_BIN_PATH, isWindows ? 'node.exe' : 'node');
+  if (fs.existsSync(bundledNode)) {
+    nodeExe = bundledNode;
+    log('  Using bundled node:', nodeExe);
+  } else {
+    log('  Bundled node not found at:', bundledNode, '- falling back to system node');
+  }
+} else {
+  log('  Using system node');
+}
+
+// Prefer bundled server if present (no tsx needed)
+const bundledServer = path.join(skillDir, 'dist', 'start-server.mjs');
+
+let tsxCommand;
+let tsxArgs;
+
+if (fs.existsSync(bundledServer)) {
+  tsxCommand = nodeExe;
+  tsxArgs = [bundledServer];
+  log('  Using bundled server:', bundledServer);
+} else {
+  // Find tsx - on Windows, ALWAYS prefer cli.mjs over tsx.cmd to avoid shell quoting issues
+  // with paths containing spaces (e.g., "C:\\Program Files\\...")
+  const localTsxJs = path.join(skillDir, 'node_modules', 'tsx', 'dist', 'cli.mjs');
+  const localTsxBin = path.join(skillDir, 'node_modules', '.bin', isWindows ? 'tsx.cmd' : 'tsx');
+
+  // On Windows: prefer cli.mjs (run via node.exe, no shell needed, no path quoting issues)
+  // On Unix: prefer the tsx binary (simpler)
+  if (isWindows && fs.existsSync(localTsxJs)) {
+    // Windows: run tsx via node directly to avoid shell quoting issues with spaces in paths
+    tsxCommand = nodeExe;
+    tsxArgs = [localTsxJs, path.join('scripts', 'start-server.ts')];
+    log('  Using tsx via node (Windows):', localTsxJs);
+  } else if (!isWindows && fs.existsSync(localTsxBin)) {
+    // Unix: use tsx binary directly
+    tsxCommand = localTsxBin;
+    tsxArgs = [path.join('scripts', 'start-server.ts')];
+    log('  Using local tsx binary (Unix):', localTsxBin);
+  } else if (fs.existsSync(localTsxJs)) {
+    // Fallback for any platform: run tsx via node directly
+    tsxCommand = nodeExe;
+    tsxArgs = [localTsxJs, path.join('scripts', 'start-server.ts')];
+    log('  Using tsx via node (fallback):', localTsxJs);
+  } else if (fs.existsSync(localTsxBin)) {
+    // Fallback: try tsx binary even on Windows (may have issues with spaces)
+    tsxCommand = localTsxBin;
+    tsxArgs = [path.join('scripts', 'start-server.ts')];
+    log('  Using local tsx binary (fallback):', localTsxBin);
+  } else {
+    // Last resort: try npx (may fail with path issues)
+    log('  WARNING: Local tsx not found, falling back to npx');
+    log('  Checked:', localTsxJs);
+    log('  Checked:', localTsxBin);
+
+    let npxCommand = isWindows ? 'npx.cmd' : 'npx';
+    if (process.env.NODE_BIN_PATH) {
+      npxCommand = path.join(process.env.NODE_BIN_PATH, isWindows ? 'npx.cmd' : 'npx');
+    }
+    tsxCommand = npxCommand;
+    tsxArgs = ['tsx', path.join('scripts', 'start-server.ts')];
+    log('  Using npx:', npxCommand);
+  }
+}
+
+// Build environment
+const env = { ...process.env };
+if (headless) {
+  env.HEADLESS = 'true';
+}
+
+log('Spawning:', tsxCommand, tsxArgs.join(' '));
+log('  cwd:', skillDir);
+
+// Spawn options
+const spawnOptions = {
+  cwd: skillDir,
+  stdio: 'inherit',
+  env,
+  windowsHide: true,
+};
+
+// On Windows, .cmd batch files REQUIRE shell: true to execute.
+// When running node directly (with cli.mjs), we can use shell: false.
+const isCmdFile = isWindows && tsxCommand.endsWith('.cmd');
+if (isCmdFile) {
+  spawnOptions.shell = true;
+  log('  shell: true (Windows .cmd file)');
+} else {
+  // For node direct execution (cli.mjs) or Unix, shell is not needed
+  spawnOptions.shell = false;
+  log('  shell: false (direct executable)');
+}
+
+const child = spawn(tsxCommand, tsxArgs, spawnOptions);
+
+child.on('error', (err) => {
+  log('ERROR: Failed to spawn:', err.message);
+  log('  Command:', tsxCommand);
+  log('  Args:', tsxArgs);
+  log('  Error code:', err.code);
+  process.exit(1);
+});
+
+child.on('close', (code, signal) => {
+  log('Process exited with code:', code, 'signal:', signal);
+  process.exit(code || 0);
+});
+
+log('Spawn initiated, waiting for process...');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@accomplish_ai/agent-core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Core logic for Accomplish - OpenCode adapter, storage, providers, MCP tools, and skills",
   "type": "module",
   "license": "MIT",
@@ -9,6 +9,19 @@
     "url": "https://github.com/accomplish-ai/accomplish.git",
     "directory": "packages/agent-core"
   },
+  "homepage": "https://github.com/accomplish-ai/accomplish/tree/main/packages/agent-core#readme",
+  "bugs": {
+    "url": "https://github.com/accomplish-ai/accomplish/issues"
+  },
+  "keywords": [
+    "automation",
+    "agent",
+    "opencode",
+    "task-manager",
+    "mcp",
+    "ai",
+    "electron"
+  ],
   "publishConfig": {
     "name": "@accomplish_ai/agent-core",
     "access": "public"
@@ -16,6 +29,7 @@
   "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -30,10 +44,9 @@
   },
   "files": [
     "dist",
-    "mcp-tools/*/src",
     "mcp-tools/*/dist",
     "mcp-tools/*/package.json",
-    "mcp-tools/*/tsconfig.json",
+    "mcp-tools/*/*.cjs",
     "mcp-tools/*/*.md",
     "mcp-tools/package.json"
   ],

package/mcp-tools/ask-user-question/src/index.ts

@@ -1,183 +0,0 @@
-#!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type CallToolResult,
-} from '@modelcontextprotocol/sdk/types.js';
-
-const QUESTION_API_PORT = process.env.QUESTION_API_PORT || '9227';
-const QUESTION_API_URL = `http://localhost:${QUESTION_API_PORT}/question`;
-
-interface QuestionOption {
-  label: string;
-  description?: string;
-}
-
-interface AskUserQuestionInput {
-  questions: Array<{
-    question: string;
-    header?: string;
-    options?: QuestionOption[];
-    multiSelect?: boolean;
-  }>;
-}
-
-const server = new Server(
-  { name: 'ask-user-question', version: '1.0.0' },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: 'AskUserQuestion',
-      description:
-        'Ask the user a question and wait for their response. Use this for clarifications, confirmations before sensitive actions, or when you need user input to proceed. Returns the user\'s selected option(s) or custom text response.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          questions: {
-            type: 'array',
-            description: 'Array of questions to ask (typically just one)',
-            items: {
-              type: 'object',
-              properties: {
-                question: {
-                  type: 'string',
-                  description: 'The question to ask the user',
-                },
-                header: {
-                  type: 'string',
-                  description: 'Short header/category for the question (max 12 chars)',
-                },
-                options: {
-                  type: 'array',
-                  description: 'Available choices for the user (2-4 options)',
-                  items: {
-                    type: 'object',
-                    properties: {
-                      label: {
-                        type: 'string',
-                        description: 'Display text for this option',
-                      },
-                      description: {
-                        type: 'string',
-                        description: 'Explanation of what this option means',
-                      },
-                    },
-                    required: ['label'],
-                  },
-                },
-                multiSelect: {
-                  type: 'boolean',
-                  description: 'Allow selecting multiple options',
-                  default: false,
-                },
-              },
-              required: ['question'],
-            },
-            minItems: 1,
-            maxItems: 4,
-          },
-        },
-        required: ['questions'],
-      },
-    },
-  ],
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (request): Promise<CallToolResult> => {
-  if (request.params.name !== 'AskUserQuestion') {
-    return {
-      content: [{ type: 'text', text: `Error: Unknown tool: ${request.params.name}` }],
-      isError: true,
-    };
-  }
-
-  const args = request.params.arguments as AskUserQuestionInput;
-  const { questions } = args;
-
-  if (!questions || questions.length === 0) {
-    return {
-      content: [{ type: 'text', text: 'Error: At least one question is required' }],
-      isError: true,
-    };
-  }
-
-  const question = questions[0];
-  if (!question.question) {
-    return {
-      content: [{ type: 'text', text: 'Error: Question text is required' }],
-      isError: true,
-    };
-  }
-
-  try {
-    const response = await fetch(QUESTION_API_URL, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        question: question.question,
-        header: question.header,
-        options: question.options,
-        multiSelect: question.multiSelect,
-      }),
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      return {
-        content: [{ type: 'text', text: `Error: Question API returned ${response.status}: ${errorText}` }],
-        isError: true,
-      };
-    }
-
-    const result = (await response.json()) as {
-      answered: boolean;
-      selectedOptions?: string[];
-      customText?: string;
-      denied?: boolean;
-    };
-
-    if (result.denied) {
-      return {
-        content: [{ type: 'text', text: 'User declined to answer the question.' }],
-      };
-    }
-
-    if (result.selectedOptions && result.selectedOptions.length > 0) {
-      return {
-        content: [{ type: 'text', text: `User selected: ${result.selectedOptions.join(', ')}` }],
-      };
-    }
-
-    if (result.customText) {
-      return {
-        content: [{ type: 'text', text: `User responded: ${result.customText}` }],
-      };
-    }
-
-    return {
-      content: [{ type: 'text', text: 'User provided no response.' }],
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      content: [{ type: 'text', text: `Error: Failed to ask question: ${errorMessage}` }],
-      isError: true,
-    };
-  }
-});
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('AskUserQuestion MCP Server started');
-}
-
-main().catch((error) => {
-  console.error('Failed to start server:', error);
-  process.exit(1);
-});

package/mcp-tools/ask-user-question/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "dist"
-  },
-  "include": ["src/**/*"]
-}

package/mcp-tools/complete-task/src/index.ts

@@ -1,92 +0,0 @@
-#!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-
-const server = new Server(
-  { name: 'complete-task', version: '1.0.0' },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: 'complete_task',
-      description:
-        'Call this tool when you have finished the task or cannot continue. You MUST call this tool to end a task - do not stop without calling it.',
-      inputSchema: {
-        type: 'object',
-        required: ['status', 'summary', 'original_request_summary'],
-        properties: {
-          status: {
-            type: 'string',
-            enum: ['success', 'blocked', 'partial'],
-            description:
-              'success = fully completed, blocked = cannot continue, partial = completed some but not all',
-          },
-          original_request_summary: {
-            type: 'string',
-            description: 'Briefly restate what the user originally asked for',
-          },
-          summary: {
-            type: 'string',
-            description: 'What you accomplished. Be specific about each part.',
-          },
-          remaining_work: {
-            type: 'string',
-            description:
-              'If blocked or partial, describe what remains and why you could not complete it',
-          },
-        },
-      },
-    },
-  ],
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  if (request.params.name !== 'complete_task') {
-    throw new Error(`Unknown tool: ${request.params.name}`);
-  }
-
-  const { status, summary, original_request_summary, remaining_work } =
-    request.params.arguments as {
-      status: 'success' | 'blocked' | 'partial';
-      summary: string;
-      original_request_summary: string;
-      remaining_work?: string;
-    };
-
-  console.error(`[complete-task] status=${status}`);
-  console.error(`[complete-task] original_request=${original_request_summary}`);
-  console.error(`[complete-task] summary=${summary}`);
-  if (remaining_work) {
-    console.error(`[complete-task] remaining=${remaining_work}`);
-  }
-
-  let responseText = `Task ${status}.`;
-  if (status === 'success') {
-    responseText = `Task completed successfully.`;
-  } else if (status === 'blocked') {
-    responseText = `Task blocked. Remaining work: ${remaining_work || 'not specified'}`;
-  } else if (status === 'partial') {
-    responseText = `Task partially completed. Remaining work: ${remaining_work || 'not specified'}`;
-  }
-
-  return {
-    content: [{ type: 'text', text: responseText }],
-  };
-});
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('[complete-task] MCP server running');
-}
-
-main().catch((error) => {
-  console.error('[complete-task] Fatal error:', error);
-  process.exit(1);
-});