mixdog 1.2.5 → 1.3.0

package/src/session-runtime/session-hooks.mjs

@@ -5,6 +5,8 @@
 // facade's hookCommonPayload / currentCwd accessor + the session itself. All
 // properties are non-enumerable/configurable/writable so the loop/manager can
 // read them by name without changing session enumeration.
+import { roomMemberOfSession } from '../runtime/agent/orchestrator/session/agent-room.mjs';
+import { roomMemberToolDecision } from './room-member-gate.mjs';
 
 export function attachSessionHooks(session, { hooks, hookCommonPayload, getCwd }) {
   const identity = (input) => ({
@@ -26,20 +28,26 @@ export function attachSessionHooks(session, { hooks, hookCommonPayload, getCwd }
   // rejection cannot escape the tool loop or the compaction flow.
   const dispatcher = (event, payload) => (input) => hooks.dispatch(event, hookCommonPayload(payload(input)));
 
-  // PreToolUse bridge.
-  define('beforeToolHook', (input, options = {}) =>
-    hooks.beforeTool(
+  // PreToolUse bridge. A group-room member's mutating calls always ask the
+  // user (room-member-gate.mjs), whatever the hooks decided short of a deny.
+  define('beforeToolHook', async (input, options = {}) => {
+    const name = input?.name || input?.tool_name;
+    const args = input?.args || input?.tool_input;
+    const cwd = input?.cwd || getCwd();
+    const decision = await hooks.beforeTool(
       hookCommonPayload({
         ...input,
         session_id: input?.sessionId || input?.session_id || session?.id,
-        tool_name: input?.name || input?.tool_name,
-        tool_input: input?.args || input?.tool_input,
+        tool_name: name,
+        tool_input: args,
         tool_use_id: input?.toolCallId || input?.tool_use_id,
-        cwd: input?.cwd || getCwd(),
+        cwd,
       }),
       options
-    )
-  );
+    );
+    if (!roomMemberOfSession(session?.id)) return decision;
+    return roomMemberToolDecision({ name, args, cwd }, decision);
+  });
   // PostToolUse: bridge runtime tool completions to the standard hook bus.
   define('afterToolHook', dispatcher('PostToolUse', toolPayload));
   // PostToolUseFailure: dispatched by loop.mjs only when a tool execution

package/src/session-runtime/setup-tool/executor.mjs

@@ -9,6 +9,12 @@ import { INSTRUCTION_FILES_MODES } from '../../runtime/shared/instruction-files-
 import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { SETUP_DESKTOP_DOMAINS, SETUP_HANDOFFS } from './settings-contract.mjs';
 import { executeExtendedSetupAction, publicAutomation, publicHookRule, validateMcpInput } from './extended-actions.mjs';
+import {
+  assertAgentEditorAccess,
+  assertInteractiveCaller,
+  assertOwnAgentSettings,
+  scheduleCallerScope,
+} from '../services/schedule-access.mjs';
 import { SETUP_DESKTOP_UNCLAIMED, createSetupUiRequests } from './ui-requests.mjs';
 import {
   SETUP_ACTIONS,
@@ -20,8 +26,11 @@ import {
 } from './tool-defs.mjs';
 import { schemaValueError } from '../../runtime/shared/schema-value-error.mjs';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
+import { CONNECTOR_IDS, connectorById } from '../../runtime/shared/connector-catalog.mjs';
 import profileConfig from '../../runtime/shared/profile-config.cjs';
 
+const AGENT_DEFINITION_ACTIONS = new Set(['create_definition', 'save_definition', 'delete_definition']);
+
 const PROFILE_VALUE_IDS = Object.freeze({
   language: profileConfig.PROFILE_LANGUAGES.map((entry) => entry.id),
   experienceLevel: ['', ...profileConfig.PROFILE_EXPERIENCE_LEVELS.map((entry) => entry.id)],
@@ -35,6 +44,7 @@ const ACTION_APPLIES_TO = {
   save_automation: 'the automation worker; scheduled runs follow the saved timing',
   delete_automation: 'future automation runs',
   set_automation_enabled: 'future automation runs',
+  run_automation: "one run now; its result posts into the owning agent's thread",
   set_webhook_config: 'the webhook worker after configuration reload',
   add_hook_rule: 'subsequent tool calls; no restart required',
   set_hook_rule_enabled: 'subsequent tool calls; no restart required',
@@ -55,9 +65,10 @@ const OPEN_TARGET_HINTS = Object.freeze({
   autoclear: 'Desktop: Settings → Context · TUI: /autoclear',
   memory:
     'Desktop: Extensions → Plugin → Built-in (Memory); core memories under Projects → project → Memories · TUI: /memory',
-  mcp: 'Desktop: Extensions → Skill tab → MCP · TUI: /mcp',
-  skills: 'Desktop: Extensions → Skill tab → Skills · TUI: /skills',
-  plugins: 'Desktop: Extensions → Plugin tab → Plugins · TUI: /plugins',
+  mcp: 'Desktop: Extensions → Connectors tab · TUI: /mcp',
+  skills: 'Desktop: Skills (activity rail) · TUI: /skills',
+  plugins:
+    'Desktop: Extensions → Extensions tab (plugins that bring MCP servers: Connectors tab → Custom connectors) · TUI: /plugins',
   update: 'Desktop: Settings → System → Update · TUI: /update',
   usage: 'Desktop: /usage in the composer · TUI: /usage',
   doctor: 'Desktop: Settings → System → Doctor, or /doctor in the composer · TUI: /doctor',
@@ -133,6 +144,7 @@ function publicProviderRows(setup) {
       pick(row, {
         reauthRequired: row.reauthRequired === true,
         expiresAt: row.expiresAt || null,
+        plan: row.plan || null,
       })
     ),
     local: (setup?.local || []).map((row) =>
@@ -167,6 +179,7 @@ function configuredProviderRows(rows, accountCount) {
         kind,
         authenticated: row.authenticated,
         status: row.status,
+        ...(kind === 'oauth' ? { plan: row.plan || null } : {}),
         ...(row.reauthRequired ? { reauthRequired: true } : {}),
         ...accounts,
       });
@@ -627,6 +640,25 @@ const SETUP_ACTION_HANDLERS = {
   remove_plugin: async (rt, args) => ({
     plugin: (await rt.removePlugin(requireText(args.name, 'name')))?.plugin || null,
   }),
+  // The chat path of the one-click connect: the attached Desktop renders this
+  // call as a connect card (agent-chat connector card) that runs the same flow
+  // as Extensions → 커넥터. Nothing is connected here.
+  connect_connector: async (rt, args) => {
+    const entry = connectorById(requireText(args.connector, 'connector'));
+    if (!entry || entry.ownKey) throw new Error(`connector must be one of ${CONNECTOR_IDS.join(', ')}`);
+    const server = (rt.mcpStatus?.()?.servers || []).find((row) => row.connector === entry.id) || null;
+    const connected = entry.backend.kind === 'builtin' ? null : server?.connected === true;
+    return {
+      connector: entry.id,
+      name: entry.name,
+      backend: entry.backend.kind,
+      ...(server ? { server: server.name } : {}),
+      connected,
+      note: connected
+        ? `${entry.name} is already connected.`
+        : `A connect card for ${entry.name} is shown in this conversation; the user presses it (Desktop: Extensions → 커넥터). Check status mcp afterwards.`,
+    };
+  },
   enable_plugin_mcp: async (rt, args) => {
     const name = requireText(args.name, 'name');
     const plugin = ((await rt.pluginsStatus())?.plugins || []).find((row) => row.name === name || row.id === name);
@@ -645,6 +677,7 @@ const READ_ONLY_SETUP_ACTIONS = new Set([
   'open',
   'list_models',
   'get_mcp_server',
+  'connect_connector',
   'read_definition',
   'search_local_models',
   'inspect_hf_model',
@@ -656,6 +689,7 @@ const BACKGROUND_SETUP_ACTIONS = new Set([
   'maintain_local_model',
   'cancel_local_installation',
   'reconnect_mcp',
+  'run_automation',
 ]);
 
 function setupMutationReceipt(action, result) {
@@ -671,7 +705,16 @@ function setupMutationReceipt(action, result) {
   );
 }
 
-export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, getSessionId, flushSettings }) {
+/** `getCallerSession(id)` returns the calling session's record (null when it
+ *  cannot be resolved): automation actions authorize by its provenance. */
+export function createSetupToolExecutor({
+  getApi,
+  getConfig,
+  notifySessionUi,
+  getSessionId,
+  getCallerSession,
+  flushSettings,
+}) {
   const desktop = createSetupUiRequests({ notifySessionUi, getSessionId });
   const api = () => {
     const facade = getApi?.();
@@ -701,12 +744,31 @@ export function createSetupToolExecutor({ getApi, getConfig, notifySessionUi, ge
     };
   }
 
-  async function execute(args, { signal }) {
+  async function execute(args, { signal, callerSessionId }) {
     signal?.throwIfAborted();
     const requestDesktop = (request) => desktop.request(request, { signal });
     const action = validateSetupInput(args);
+    // The session that made this call, not just the runtime's own Lead.
+    const sessionId = clean(callerSessionId) || clean(getSessionId?.());
+    const caller = (sessionId && getCallerSession?.(sessionId)) || null;
+    // A headless run (schedule, webhook, delegated agent) only reads settings:
+    // it never creates agents, definitions or automations, nor changes any
+    // other setting. Hosts without session provenance (no getCallerSession)
+    // skip this gate; automation actions still refuse an unknown caller.
+    if (getCallerSession && !READ_ONLY_SETUP_ACTIONS.has(action)) {
+      const scope = scheduleCallerScope(caller);
+      assertInteractiveCaller(scope, action);
+      // Agent definitions (contacts) change only from Mixy; another agent's
+      // home changes only its own agent settings.
+      if (AGENT_DEFINITION_ACTIONS.has(action) && args.definitionKind === 'agent') {
+        assertAgentEditorAccess(scope, caller, action);
+      }
+      if (action === 'set_agent_route') assertOwnAgentSettings(scope, args.agent, action);
+    }
     const rt = action === 'status' || action === 'open' ? null : api();
-    if (!Object.hasOwn(SETUP_ACTION_HANDLERS, action)) return executeExtendedSetupAction(rt, args, requestDesktop);
+    if (!Object.hasOwn(SETUP_ACTION_HANDLERS, action)) {
+      return executeExtendedSetupAction(rt, args, requestDesktop, { sessionId, caller });
+    }
     return SETUP_ACTION_HANDLERS[action](rt, args, { requestDesktop, readStatus, openSurface });
   }
 

package/src/session-runtime/setup-tool/extended-actions.mjs

@@ -1,6 +1,8 @@
 import { SETUP_EXTENDED_PROPERTIES, SETUP_DESKTOP_ACTIONS } from './settings-contract.mjs';
 import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { OPENAI_COMPAT_PRESETS } from '../../runtime/agent/orchestrator/providers/openai-compat-presets.mjs';
+import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { assertAutomationAccess, scheduleCallerScope } from '../services/schedule-access.mjs';
 
 const own = (value, key) => Object.hasOwn(value || {}, key);
 const pick = (value, keys) => Object.fromEntries(keys.filter((key) => own(value, key)).map((key) => [key, value[key]]));
@@ -203,6 +205,26 @@ async function saveDefinition(rt, args) {
   return creating ? rt.addSkill(next) : rt.saveSkill({ ...next, originalName: current.originalName });
 }
 
+async function automationRow(rt, kind, name) {
+  const status = await rt.getChannelSetup();
+  return status[kind === 'schedule' ? 'schedules' : 'webhooks'].find((row) => row.name === name) || null;
+}
+
+/** Authorize one automation action for the calling session (`context.caller`,
+ *  its session record; null when it could not be resolved) — schedule-access.mjs. */
+async function authorizeAutomation(rt, context, { kind, action, current, owner = '' }) {
+  const scope = scheduleCallerScope(context.caller);
+  const transfer = String(owner ?? '').trim();
+  const agents = transfer && scope.kind === 'human' ? await rt.listAgents() : [];
+  assertAutomationAccess(scope, {
+    kind,
+    action,
+    current,
+    owner: transfer,
+    agentIds: (Array.isArray(agents) ? agents : []).map((agent) => agent?.id).filter(Boolean),
+  });
+}
+
 export const EXTENDED_SETUP_HANDLERS = Object.freeze({
   set_local_context: (rt, args) => rt.setLocalProviderContext(args.modelId, args.localContextWindow),
   async list_models(rt, args) {
@@ -238,22 +260,29 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
     return {
       ...result,
       recovery:
-        'User-authored definition files are deleted. A built-in override may revert to its built-in definition.',
+        args.definitionKind === 'workflow'
+          ? 'User-authored definition files are deleted. A built-in override may revert to its built-in definition.'
+          : 'A custom agent or bot is archived with its chat and its routines are switched off; the user can restore it from Sessions → Archived, or delete it there for good. A built-in override reverts to its built-in definition.',
     };
   },
-  async save_automation(rt, args) {
+  async save_automation(rt, args, context = {}) {
     const kind = args.automationKind;
     const input = args.entry;
     if (kind === 'webhook' && ['time', 'at', 'timezone', 'days'].some((key) => own(input, key))) {
-      throw new Error('Schedule timing fields are not accepted for webhooks');
+      throw new Error('Schedule fields (timing) are not accepted for webhooks');
     }
     if (kind === 'schedule' && own(input, 'parser')) throw new Error('parser is a webhook-only field');
     let previous = {};
     if (input.overwrite) {
-      const status = await rt.getChannelSetup();
-      previous = status[kind === 'schedule' ? 'schedules' : 'webhooks'].find((row) => row.name === input.name);
+      previous = await automationRow(rt, kind, input.name);
       if (!previous) throw new Error(`${kind} "${input.name}" does not exist`);
     }
+    await authorizeAutomation(rt, context, {
+      kind,
+      action: input.overwrite ? 'edit' : 'create',
+      current: input.overwrite ? previous : null,
+      owner: input.owner,
+    });
     const next = { ...pick(previous, entryKeys), ...input };
     if (kind === 'schedule') {
       if (previous.whenAt && !own(input, 'time') && !own(input, 'at')) {
@@ -263,6 +292,11 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
       if (own(input, 'time') && !own(input, 'at')) delete next.at;
       if (own(input, 'at') && !own(input, 'time')) delete next.time;
     }
+    // An automation created from an agent's home thread belongs to that agent.
+    if (!input.overwrite && !own(input, 'owner')) {
+      const homeAgent = agentIdOfHomeSession(context.sessionId);
+      if (homeAgent) next.owner = homeAgent;
+    }
     const result = kind === 'schedule' ? await rt.saveSchedule(next) : await rt.saveWebhook(next);
     return {
       ...publicAutomation(result),
@@ -275,18 +309,42 @@ export const EXTENDED_SETUP_HANDLERS = Object.freeze({
         : {}),
     };
   },
-  async delete_automation(rt, args) {
-    const status = await rt.getChannelSetup();
-    const rows = status[args.automationKind === 'schedule' ? 'schedules' : 'webhooks'];
-    if (!rows.some((row) => row.name === args.name)) throw new Error('Automation entry not found');
+  async delete_automation(rt, args, context = {}) {
+    const current = await automationRow(rt, args.automationKind, args.name);
+    if (!current) throw new Error('Automation entry not found');
+    await authorizeAutomation(rt, context, { kind: args.automationKind, action: 'delete', current });
     const result =
       args.automationKind === 'schedule' ? await rt.deleteSchedule(args.name) : await rt.deleteWebhook(args.name);
     return { ...result, recovery: 'The automation record is deleted; recreating it requires its definition.' };
   },
-  set_automation_enabled: (rt, args) =>
-    args.automationKind === 'schedule'
+  async set_automation_enabled(rt, args, context = {}) {
+    const current = await automationRow(rt, args.automationKind, args.name);
+    if (!current) throw new Error('Automation entry not found');
+    const action = args.enabled === false ? 'pause' : 'resume';
+    await authorizeAutomation(rt, context, { kind: args.automationKind, action, current });
+    return args.automationKind === 'schedule'
       ? rt.setScheduleEnabled(args.name, args.enabled)
-      : rt.setWebhookEnabled(args.name, args.enabled),
+      : rt.setWebhookEnabled(args.name, args.enabled);
+  },
+  // Starts the run and returns at once: the run is its own session, and its
+  // result posts into the owning agent's thread when it ends. A webhook
+  // re-runs on its latest received payload.
+  async run_automation(rt, args, context = {}) {
+    const kind = args.automationKind;
+    const current = await automationRow(rt, kind, args.name);
+    if (!current) throw new Error('Automation entry not found');
+    await authorizeAutomation(rt, context, { kind, action: 'run', current });
+    if (kind === 'webhook' && current.hasLastPayload !== true) {
+      throw new Error(`webhook "${args.name}" has not received a payload yet`);
+    }
+    const run = kind === 'webhook' ? rt.runWebhookNow(args.name) : rt.runScheduleNow(args.name);
+    void Promise.resolve(run).catch(() => {});
+    return {
+      name: args.name,
+      started: true,
+      note: "The run is its own session; its result posts into the owning agent's thread when it finishes.",
+    };
+  },
   async set_developer_option(rt, args) {
     const option = rt
       .getDeveloperSettings()
@@ -360,9 +418,9 @@ function hookRuleAt(rt, index) {
   return publicHookRule(rule);
 }
 
-export async function executeExtendedSetupAction(rt, args, requestDesktop) {
+export async function executeExtendedSetupAction(rt, args, requestDesktop, context = {}) {
   if (SETUP_DESKTOP_ACTIONS.includes(args.action)) return requestDesktop(args);
   const handler = EXTENDED_SETUP_HANDLERS[args.action];
   if (!handler) throw new Error(`setup: unhandled action "${args.action}"`);
-  return handler(rt, args);
+  return handler(rt, args, context);
 }

package/src/session-runtime/setup-tool/settings-contract.mjs

@@ -26,6 +26,7 @@ export const SETUP_EXTENDED_ACTION_FIELDS = Object.freeze({
   save_automation: 'automationKind entry',
   delete_automation: 'automationKind name',
   set_automation_enabled: 'automationKind name enabled',
+  run_automation: 'automationKind name',
   set_webhook_config: 'webhook',
   set_desktop_settings: 'desktop',
   set_appearance: 'appearance',
@@ -51,6 +52,7 @@ export const SETUP_ACTIVITY_RAIL_PIN_IDS = Object.freeze([
   'workflows',
   'projects',
   'extensions',
+  'skills',
   'source-control',
   'search',
   'webhooks',
@@ -172,13 +174,7 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
       timezone: text,
       days: { ...text, description: 'Schedule day selector, e.g. weekdays or mon,wed,fri.' },
       parser: { type: 'string', enum: ['github', 'generic', 'stripe', 'sentry'] },
-      model: {
-        ...text,
-        description:
-          'Required for new schedules; no default-model fallback. Use provider/model[@effort][+fast][+noauto][?parameter=value] (+noauto: Auto reasoning off; absent = on) or an existing preset name. On overwrite, omission preserves the saved model, which must be non-empty.',
-      },
       cwd: text,
-      workflow: text,
       attachments: {
         type: 'array',
         maxItems: 8,
@@ -197,6 +193,11 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
         ),
       },
       enabled: boolean,
+      owner: {
+        ...text,
+        description:
+          "The bot id that owns the schedule or webhook; each run is a turn in that bot's chat, where it replies with the result. The bot must exist (no representative bot yet = refused). New entries default to the bot of the calling thread (the representative bot = lead); on overwrite, omission keeps the owner.",
+      },
       overwrite: { ...boolean, description: 'Explicitly update an existing entry; omitted fields are preserved.' },
     },
     ['name']
@@ -213,6 +214,7 @@ export const SETUP_EXTENDED_PROPERTIES = Object.freeze({
     usagePinned: boolean,
     usageRailShortLong: boolean,
     computerObserveOnly: boolean,
+    browserAutoSignIn: boolean,
     notificationVolume: {
       type: 'integer',
       minimum: 0,

package/src/session-runtime/setup-tool/tool-defs.mjs

@@ -7,6 +7,7 @@ import {
 import { MEDIA_KINDS } from '../../runtime/media/tool-defs.mjs';
 import { INSTRUCTION_FILES_MODES } from '../../runtime/shared/instruction-files-mode.mjs';
 import { WORKTREE_NEW_TASK_DEFAULTS } from '../../runtime/shared/worktrees/settings.mjs';
+import { CONNECTOR_IDS } from '../../runtime/shared/connector-catalog.mjs';
 
 /** Built-in `setup` tool: the model's handle on a Mixdog user's persisted
  *  configuration. The description is a contract only; how to use each action
@@ -110,6 +111,7 @@ export const SETUP_ACTION_FIELDS = Object.freeze({
   set_plugin_enabled: 'name enabled',
   remove_plugin: 'name',
   enable_plugin_mcp: 'name',
+  connect_connector: 'connector',
   set_worktree_settings: 'worktree',
   ...SETUP_EXTENDED_ACTION_FIELDS,
 });
@@ -345,6 +347,12 @@ export const SETUP_TOOL_DEFS = Object.freeze([
           description: 'set_disabled_skills: full list of disabled skill names.',
         },
         source: { type: 'string', description: 'add_plugin: Git URL, owner/repo, or local path.' },
+        connector: {
+          type: 'string',
+          enum: [...CONNECTOR_IDS],
+          description:
+            'connect_connector: catalog service to connect. Shows the user a connect card in this conversation (one-click sign-in or a key sheet in Desktop); it never connects by itself.',
+        },
         kind: {
           type: 'string',
           enum: ['skills', 'mcp', 'plugins', ...MEDIA_KINDS],

package/src/session-runtime/skills-api.mjs

@@ -1,7 +1,7 @@
 // Skill surface (status listing, resource load, tool envelope, global skill
 // creation/editing). The runtime facade only wires the mutable cwd and the
 // context module into it.
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { resolvePluginData } from '../runtime/shared/plugin-paths.mjs';
 import {
@@ -193,6 +193,20 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
     return { originalName, name, filePath };
   }
 
+  function removeGlobalSkill(input = {}) {
+    const name = validateSkillName(input.name);
+    const resource = contextMod.loadSkillResource?.(name, getCwd());
+    if (!resource?.filePath) throw new Error(`skill not found: ${name}`);
+    const dir = dirname(resolve(resource.filePath));
+    const rel = relative(globalSkillsRoot(), dir);
+    if (!rel || rel.startsWith('..') || isAbsolute(rel) || basename(dir) !== name) {
+      throw new Error(`only your own skills can be removed: ${name}`);
+    }
+    rmSync(dir, { recursive: true, force: true });
+    invalidateSkills();
+    return { name };
+  }
+
   function invalidateSkills() {
     contextMod.invalidateSkillsCache?.(getCwd());
   }
@@ -203,6 +217,7 @@ export function createSkillsApi({ contextMod, getCwd, getTools = () => [] }) {
     skillToolContent,
     addGlobalSkill,
     saveSkillDocument,
+    removeGlobalSkill,
     invalidateSkills,
   };
 }