amalgm 0.1.88 → 0.1.89

package/runtime/scripts/amalgm-mcp/project-context/tools.js

@@ -0,0 +1,146 @@
+'use strict';
+
+/**
+ * memories — project memory tools (toolbox group `memories`).
+ *
+ * The model supplies content only. The runtime owns project resolution,
+ * timestamps, placement, revisions, the SQLite row, and Local Live events.
+ * Default project comes from the calling session's working directory; an
+ * explicit projectPath allows cross-project writes as long as the path lands
+ * inside a registered Amalgm project.
+ */
+
+const { textResult, errorResult } = require('../lib/tool-result');
+const store = require('./store');
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+
+function targetPathFor(args, context) {
+  return cleanString(args?.projectPath)
+    || cleanString(context?.sessionMetadata?.cwd)
+    || cleanString(context?.sessionMetadata?.projectPath)
+    || '';
+}
+
+function noProjectError(targetPath) {
+  const where = targetPath ? ` for: ${targetPath}` : ' (no working directory on this session and no projectPath given)';
+  return errorResult(
+    `No registered Amalgm project found${where}. `
+    + 'Pass projectPath pointing inside a project that was added to Amalgm via the working-directory picker.',
+  );
+}
+
+const PROJECT_PATH_INPUT = {
+  type: 'string',
+  description:
+    'Optional absolute path inside a registered Amalgm project. Defaults to the current session\'s project (its working directory). Use only for cross-project writes.',
+};
+
+module.exports = [
+  {
+    name: 'append_change_log',
+    description:
+      'Append an entry to the active project\'s change log (change-log.md). Call this when durable, user-visible work is completed, a decision is made, or future agents need to know something. The runtime writes the timestamp (user\'s local time and timezone) and places the entry newest-first — submit ONLY the entry body.\n\nBody format: 3-6 concise, factual markdown bullets. Prefer:\n- Completed: short factual summary of what changed.\n- Decisions: durable choices made.\n- Notes: anything future agents should know.\n\nNo transcripts, no timestamps, no headings, no essays. Mark speculation explicitly as an open question.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        body: {
+          type: 'string',
+          description: 'Markdown body of the entry (bullets only, no timestamp heading).',
+        },
+        projectPath: PROJECT_PATH_INPUT,
+      },
+      required: ['body'],
+    },
+    async handler({ body, projectPath } = {}, context = {}) {
+      const target = targetPathFor({ projectPath }, context);
+      if (!target) return noProjectError('');
+      try {
+        const result = store.appendChangeLog(target, body, {
+          source: 'project-context:tool',
+        });
+        return textResult(
+          `Change log entry recorded for ${result.project.name} at ${result.timestamp.iso} [${result.timestamp.timeZone}].\n`
+          + `File: ${result.record?.paths?.changeLog || ''}`,
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.startsWith('No registered Amalgm project')) return noProjectError(target);
+        return errorResult(message);
+      }
+    },
+  },
+  {
+    name: 'write_project_state',
+    description:
+      'Rewrite the active project\'s consolidated state document (project-state.md). This is the "where the project stands now" snapshot injected into future sessions — use it to consolidate, not to log events (use append_change_log for history). Latest write wins; submit the COMPLETE new document as markdown. Keep it factual, current, and concise; remove stale information instead of appending.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'Full markdown content of the new project-state.md (start with "# Project State").',
+        },
+        projectPath: PROJECT_PATH_INPUT,
+      },
+      required: ['content'],
+    },
+    async handler({ content, projectPath } = {}, context = {}) {
+      const target = targetPathFor({ projectPath }, context);
+      if (!target) return noProjectError('');
+      if (typeof content !== 'string' || !content.trim()) {
+        return errorResult('content is required (full markdown for project-state.md)');
+      }
+      try {
+        const result = store.writeProjectState(target, content, {
+          source: 'project-context:tool',
+        });
+        return textResult(
+          `Project state updated for ${result.project.name} (revision ${result.record?.files?.projectState?.revision || 'unknown'}).\n`
+          + `File: ${result.record?.paths?.projectState || ''}`,
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.startsWith('No registered Amalgm project')) return noProjectError(target);
+        return errorResult(message);
+      }
+    },
+  },
+  {
+    name: 'read_project_context',
+    description:
+      'Read the active project\'s memory: instructions.md (user-authored), project-state.md (consolidated snapshot), and the recent change-log.md window (newest first). Use when you need to re-check project memory mid-session or inspect another project\'s context via projectPath.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        projectPath: PROJECT_PATH_INPUT,
+      },
+    },
+    async handler({ projectPath } = {}, context = {}) {
+      const target = targetPathFor({ projectPath }, context);
+      if (!target) return noProjectError('');
+      try {
+        const record = store.getProjectContext(target, { source: 'project-context:tool-read' });
+        if (!record) return noProjectError(target);
+        const sections = [
+          `Project: ${record.name} (${record.projectPath})`,
+          `Context revision: ${record.contextRevision}`,
+          '',
+          '## instructions.md',
+          record.prompt?.instructions || '(empty)',
+          '',
+          '## project-state.md',
+          record.prompt?.projectState || '(empty)',
+          '',
+          '## change-log.md (recent)',
+          record.prompt?.changeLogRecent || '(empty)',
+        ];
+        return textResult(sections.join('\n'));
+      } catch (error) {
+        return errorResult(error instanceof Error ? error.message : String(error));
+      }
+    },
+  },
+];

package/runtime/scripts/amalgm-mcp/server/core-tools.js

@@ -8,7 +8,7 @@
  * circular dependency on the MCP server.
  */
 
-function group(id, name, description, tools) {
+function group(id, name, description, tools, extra = {}) {
   return {
     id,
     name,
@@ -17,6 +17,7 @@ function group(id, name, description, tools) {
     origin: 'system',
     status: 'enabled',
     description,
+    ...extra,
     tools: tools.map((tool) => ({
       ...tool,
       toolboxToolId: id,
@@ -39,6 +40,12 @@ const CORE_TOOL_GROUPS = [
     'Notify the user about important results, completions, and failures.',
     require('../notify'),
   ),
+  group(
+    'memories',
+    'Memories',
+    'Maintain project memory: append change-log entries and keep the project-state snapshot current.',
+    require('../project-context/tools'),
+  ),
   group(
     'agents',
     'Agents',
@@ -51,11 +58,37 @@ const CORE_TOOL_GROUPS = [
     'Register, run, and route local-first Amalgm apps.',
     require('../apps/tools'),
   ),
+  // The Browser family: one product primitive ("browser") plus optional
+  // capabilities that stay separately grantable but present as Browser modes,
+  // not peer products. `family`/`capability` flow into the toolbox catalog so
+  // UIs can nest them under Browser.
   group(
     'browser',
     'Browser',
-    "Use Amalgm's visible browser session for navigation, interaction, and screenshots.",
+    "Drive Amalgm's browser: open pages, snapshot interactive elements, click, fill, and run any agent-browser CLI command.",
     require('../browser/tools'),
+    { family: 'browser', capability: 'core' },
+  ),
+  group(
+    'browser_cua',
+    'Browser Computer Use',
+    'Browser capability: coordinate/pixel control for vision-model loops — screenshot, click and type at x/y.',
+    require('../browser/cua-tools'),
+    { family: 'browser', capability: 'computer-use' },
+  ),
+  group(
+    'browser_recording',
+    'Browser Recording',
+    'Browser capability: record sessions to WebM videos stored with the Amalgm project they belong to.',
+    require('../browser/recorder-tools'),
+    { family: 'browser', capability: 'recording' },
+  ),
+  group(
+    'browser_auth',
+    'Browser Auth',
+    'Browser infrastructure: durable profiles, encrypted auth bundles, and temporary login links.',
+    require('../browser/auth-tools'),
+    { family: 'browser', capability: 'auth' },
   ),
 ];
 

package/runtime/scripts/amalgm-mcp/server/local-service-router.js

@@ -17,6 +17,7 @@ const { handleAgentRoutes } = require('./routes/agents');
 const { handleEventRoutes } = require('./routes/events');
 const { handleAutomationRoutes } = require('./routes/automations');
 const { handleWorkspaceRoutes } = require('./routes/workspace');
+const { handleProjectContextRoutes } = require('./routes/project-context');
 const { handleFileRoutes } = require('./routes/files');
 const { handleToolboxRoutes } = require('./routes/toolbox');
 const { handleLocalRoutes } = require('./routes/local');
@@ -34,6 +35,7 @@ const DEFAULT_ROUTE_GROUPS = [
   handleEventRoutes,
   handleAutomationRoutes,
   handleWorkspaceRoutes,
+  handleProjectContextRoutes,
   handleFileRoutes,
   handleToolboxRoutes,
   handleLocalRoutes,

package/runtime/scripts/amalgm-mcp/server/routes/project-context.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const projectContextRest = require('../../project-context/rest');
+
+async function handleProjectContextRoutes(ctx) {
+  if (ctx.pathname === '/project-context' && ctx.method === 'GET') {
+    await projectContextRest.handleGet(ctx.getQuery(), ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/project-context/list' && ctx.method === 'GET') {
+    await projectContextRest.handleList(ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/project-context/change-log' && ctx.method === 'POST') {
+    await projectContextRest.handleAppendChangeLog(await ctx.readJsonBody(), ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/project-context/change-log' && ctx.method === 'PUT') {
+    await projectContextRest.handleWriteChangeLog(await ctx.readJsonBody(), ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/project-context/project-state' && ctx.method === 'PUT') {
+    await projectContextRest.handleWriteProjectState(await ctx.readJsonBody(), ctx.sendJson);
+    return true;
+  }
+  if (ctx.pathname === '/project-context/instructions' && ctx.method === 'PUT') {
+    await projectContextRest.handleWriteInstructions(await ctx.readJsonBody(), ctx.sendJson);
+    return true;
+  }
+  return false;
+}
+
+module.exports = { handleProjectContextRoutes };

package/runtime/scripts/amalgm-mcp/state/db.js

@@ -319,6 +319,17 @@ function migrate(database = openLocalDb()) {
     CREATE INDEX IF NOT EXISTS agent_configs_updated_idx
       ON agent_configs(updated_at DESC);
 
+    CREATE TABLE IF NOT EXISTS project_context (
+      project_id TEXT PRIMARY KEY,
+      project_path TEXT NOT NULL,
+      context_revision TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      context_json TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS project_context_path_idx
+      ON project_context(project_path);
+
     CREATE TABLE IF NOT EXISTS workspaces (
       id TEXT PRIMARY KEY,
       name TEXT NOT NULL,

package/runtime/scripts/amalgm-mcp/state/snapshot.js

@@ -2,7 +2,7 @@
 
 const { currentSeq } = require('./events');
 
-const DEFAULT_RESOURCES = ['automations', 'triggers', 'workflows', 'automation_runs', 'workflow_cell_runs', 'agents', 'agent_configs', 'apps', 'toolbox', 'tools', 'tool_actions', 'hooks', 'projects', 'workspaces', 'memories', 'user_preferences', 'chat_payloads', 'mcp_connections', 'browser_profiles', 'browser_auth_bundles', 'browser_login_sessions'];
+const DEFAULT_RESOURCES = ['automations', 'triggers', 'workflows', 'automation_runs', 'workflow_cell_runs', 'agents', 'agent_configs', 'apps', 'toolbox', 'tools', 'tool_actions', 'hooks', 'projects', 'workspaces', 'project_context', 'user_preferences', 'chat_payloads', 'mcp_connections', 'browser_profiles', 'browser_auth_bundles', 'browser_login_sessions'];
 
 function normalizeResources(resources) {
   const values = resources ? String(resources).split(',') : DEFAULT_RESOURCES;
@@ -59,8 +59,8 @@ function readResource(resource, cache) {
       const workspaceStore = require('../workspace/store');
       return workspaceStore.listWorkspaces();
     }
-    case 'memories':
-      return require('../../chat-core/tooling/active-memory').collectActiveMemoryFiles();
+    case 'project_context':
+      return require('../project-context/store').listProjectContexts();
     case 'user_preferences':
       return require('../lib/prefs').readUserPreferences();
     case 'chat_payloads':

package/runtime/scripts/amalgm-mcp/tests/core-tools.test.js

@@ -9,9 +9,13 @@ test('core tools are grouped into first-party toolbox-style defaults', () => {
   assert.deepEqual(CORE_TOOL_GROUPS.map((group) => group.id), [
     'automations',
     'notifications',
+    'memories',
     'agents',
     'apps',
     'browser',
+    'browser_cua',
+    'browser_recording',
+    'browser_auth',
   ]);
   assert.equal(CORE_TOOL_GROUPS.every((group) => group.origin === 'system'), true);
   assert.equal(CORE_TOOL_GROUPS.every((group) => group.owner === 'amalgm'), true);
@@ -22,16 +26,45 @@ test('core tool grouping preserves handler definitions for MCP surface wrapping'
 
   assert.equal(CORE_TOOLS.length, groupedTools.length);
   assert.deepEqual(CORE_TOOLS.map((tool) => tool.name), groupedTools.map((tool) => tool.name));
-  assert.equal(CORE_TOOLS.some((tool) => tool.name === 'browser_navigate'), true);
+  assert.equal(CORE_TOOLS.some((tool) => tool.name === 'browser_open'), true);
   assert.equal(CORE_TOOLS.some((tool) => tool.name === 'notify_user'), true);
+  assert.equal(CORE_TOOLS.some((tool) => tool.name === 'append_change_log'), true);
 });
 
 test('core tool actions carry stable toolbox ids', () => {
-  const browserNavigate = CORE_TOOLS.find((tool) => tool.name === 'browser_navigate');
+  const browserOpen = CORE_TOOLS.find((tool) => tool.name === 'browser_open');
   const notifyUser = CORE_TOOLS.find((tool) => tool.name === 'notify_user');
 
-  assert.equal(browserNavigate.toolboxToolId, 'browser');
-  assert.equal(browserNavigate.toolboxActionId, 'browser.browser_navigate');
+  assert.equal(browserOpen.toolboxToolId, 'browser');
+  assert.equal(browserOpen.toolboxActionId, 'browser.browser_open');
   assert.equal(notifyUser.toolboxToolId, 'notifications');
   assert.equal(notifyUser.toolboxActionId, 'notifications.notify_user');
 });
+
+test('browser surface stays thin and cua/recorder are separate groups', () => {
+  const browser = CORE_TOOL_GROUPS.find((group) => group.id === 'browser');
+  assert.deepEqual(browser.tools.map((tool) => tool.name), [
+    'browser_open',
+    'browser_snapshot',
+    'browser_screenshot',
+    'browser_click',
+    'browser_fill',
+    'browser_press',
+    'browser_eval',
+    'browser_wait',
+    'browser_cli',
+    'browser_close',
+  ]);
+
+  const cua = CORE_TOOL_GROUPS.find((group) => group.id === 'browser_cua');
+  assert.equal(cua.tools.every((tool) => tool.name.startsWith('cua_')), true);
+
+  const recorder = CORE_TOOL_GROUPS.find((group) => group.id === 'browser_recording');
+  assert.deepEqual(recorder.tools.map((tool) => tool.name), ['record_start', 'record_stop', 'record_list']);
+});
+
+test('browser capability groups carry family metadata for nested presentation', () => {
+  const family = CORE_TOOL_GROUPS.filter((group) => group.family === 'browser');
+  assert.deepEqual(family.map((group) => group.id), ['browser', 'browser_cua', 'browser_recording', 'browser_auth']);
+  assert.deepEqual(family.map((group) => group.capability), ['core', 'computer-use', 'recording', 'auth']);
+});