@robota-sdk/agent-command 3.0.0-beta.79 → 3.0.0-beta.81

package/src/rewind/rewind-command.ts

@@ -3,15 +3,18 @@ import {
   listCommandEditCheckpoints,
   restoreCommandEditCheckpoint,
   rollbackCommandEditCheckpoint,
+  forkCommandEditCheckpoint,
+  switchCommandEditCheckpointBranch,
+  listCommandEditCheckpointBranches,
 } from '@robota-sdk/agent-framework';
 
 import type {
-  ICommandHostContext,
+  ICommandHostCheckpoints,
   IEditCheckpointInspection,
   IEditCheckpointRestoreResult,
   IEditCheckpointSummary,
 } from '@robota-sdk/agent-framework';
-import type { ICommandResult } from '@robota-sdk/agent-interface-transport';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
 
 const SUBCOMMAND_INDEX = 0;
 const CHECKPOINT_ID_INDEX = 1;
@@ -125,7 +128,10 @@ function formatError(error: Error | string): ICommandResult {
   };
 }
 
-function inspect(context: ICommandHostContext, checkpointId: string | undefined): ICommandResult {
+function inspect(
+  context: ICommandHostCheckpoints,
+  checkpointId: string | undefined,
+): ICommandResult {
   if (!checkpointId) return usage();
   try {
     return formatInspection(inspectCommandEditCheckpoint(context, checkpointId));
@@ -135,7 +141,7 @@ function inspect(context: ICommandHostContext, checkpointId: string | undefined)
 }
 
 async function restore(
-  context: ICommandHostContext,
+  context: ICommandHostCheckpoints,
   checkpointId: string | undefined,
 ): Promise<ICommandResult> {
   if (!checkpointId) return usage();
@@ -147,7 +153,7 @@ async function restore(
 }
 
 async function rollback(
-  context: ICommandHostContext,
+  context: ICommandHostCheckpoints,
   checkpointId: string | undefined,
 ): Promise<ICommandResult> {
   if (!checkpointId) return usage();
@@ -158,8 +164,58 @@ async function rollback(
   }
 }
 
+// SELFHOST-007: branching time-travel handlers.
+async function fork(
+  context: ICommandHostCheckpoints,
+  checkpointId: string | undefined,
+): Promise<ICommandResult> {
+  if (!checkpointId) return usage();
+  try {
+    const result = await forkCommandEditCheckpoint(context, checkpointId);
+    return {
+      message: [
+        `Forked a new branch from ${result.target.id} (the previous future is preserved).`,
+        `Restored files: ${result.restoredFileCount}`,
+      ].join('\n'),
+      success: true,
+      data: { target: result.target, restoredFileCount: result.restoredFileCount },
+    };
+  } catch (error) {
+    return formatError(error instanceof Error ? error : String(error));
+  }
+}
+
+function switchBranch(
+  context: ICommandHostCheckpoints,
+  checkpointId: string | undefined,
+): ICommandResult {
+  if (!checkpointId) return usage();
+  try {
+    switchCommandEditCheckpointBranch(context, checkpointId);
+    return { message: `Switched to checkpoint branch ${checkpointId}.`, success: true };
+  } catch (error) {
+    return formatError(error instanceof Error ? error : String(error));
+  }
+}
+
+function branches(context: ICommandHostCheckpoints): ICommandResult {
+  try {
+    const tips = listCommandEditCheckpointBranches(context);
+    return {
+      message:
+        tips.length === 0
+          ? 'No checkpoint branches yet.'
+          : `Branch tips:\n${tips.map((id) => `- ${id}`).join('\n')}`,
+      success: true,
+      data: { branches: tips },
+    };
+  } catch (error) {
+    return formatError(error instanceof Error ? error : String(error));
+  }
+}
+
 export async function executeRewindCommand(
-  context: ICommandHostContext,
+  context: ICommandHostCheckpoints,
   rawArgs: string,
 ): Promise<ICommandResult> {
   const args = rawArgs.trim().split(/\s+/).filter(Boolean);
@@ -181,5 +237,16 @@ export async function executeRewindCommand(
     return rollback(context, args[CHECKPOINT_ID_INDEX]);
   }
 
+  // SELFHOST-007: branching time-travel subcommands.
+  if (subcommand === 'fork') {
+    return fork(context, args[CHECKPOINT_ID_INDEX]);
+  }
+  if (subcommand === 'switch') {
+    return switchBranch(context, args[CHECKPOINT_ID_INDEX]);
+  }
+  if (subcommand === 'branches') {
+    return branches(context);
+  }
+
   return usage();
 }

package/src/sandbox/__tests__/sandbox-command.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { executeSandboxCommand } from '../sandbox-command.js';
+
+import type {
+  ICommandSandboxAdapter,
+  ICommandSandboxStatus,
+  TSandboxCommandMode,
+} from '@robota-sdk/agent-framework';
+
+/** Issue #3082 — `/sandbox` shows and changes how shell commands are confined. */
+function contextWith(
+  status: Partial<ICommandSandboxStatus>,
+  answer?: string,
+): { context: Parameters<typeof executeSandboxCommand>[0]; setMode: ReturnType<typeof vi.fn> } {
+  let current: ICommandSandboxStatus = {
+    mode: 'off',
+    backend: 'bubblewrap',
+    network: false,
+    excludedCommands: [],
+    ...status,
+  };
+  const setMode = vi.fn((mode: TSandboxCommandMode) => {
+    current = { ...current, mode };
+  });
+  const adapter: ICommandSandboxAdapter = { status: () => current, setMode };
+  const ui =
+    answer === undefined
+      ? undefined
+      : { ask: vi.fn().mockResolvedValue({ type: 'answer', values: [answer] }) };
+  return {
+    context: {
+      getCommandHostAdapters: () => ({ sandbox: adapter }),
+      getUserInteraction: () => ui,
+    } as never,
+    setMode,
+  };
+}
+
+describe('/sandbox', () => {
+  it('shows the current state when no mode is given and nobody is asked', async () => {
+    const { context } = contextWith({ mode: 'auto-allow', excludedCommands: ['docker'] });
+    const result = await executeSandboxCommand(context, '');
+    expect(result.message).toContain('Sandbox: auto-allow (bubblewrap)');
+    expect(result.message).toContain('Network: blocked.');
+    expect(result.message).toContain('Run unconfined: docker.');
+  });
+
+  it('sets a mode named on the command line', async () => {
+    const { context, setMode } = contextWith({});
+    const result = await executeSandboxCommand(context, 'regular');
+    expect(setMode).toHaveBeenCalledWith('regular');
+    expect(result.message).toContain('Sandbox mode set to: regular');
+  });
+
+  it('asks for a mode through the picker', async () => {
+    const { context, setMode } = contextWith({}, 'auto-allow');
+    await executeSandboxCommand(context, '');
+    expect(setMode).toHaveBeenCalledWith('auto-allow');
+  });
+
+  it('says what is missing when the backend cannot run', async () => {
+    const { context } = contextWith({ mode: 'auto-allow', unavailable: 'missing bubblewrap' });
+    const result = await executeSandboxCommand(context, '');
+    expect(result.message).toContain(
+      'Cannot run here: missing bubblewrap. Commands run unconfined.',
+    );
+  });
+
+  it('refuses an unknown mode and a host without a sandbox', async () => {
+    const { context, setMode } = contextWith({});
+    expect((await executeSandboxCommand(context, 'loose')).success).toBe(false);
+    expect(setMode).not.toHaveBeenCalled();
+    const bare = {
+      getCommandHostAdapters: () => ({}),
+      getUserInteraction: () => undefined,
+    } as never;
+    expect((await executeSandboxCommand(bare, '')).message).toBe('This host has no OS sandbox.');
+  });
+});

package/src/sandbox/index.ts

@@ -0,0 +1,2 @@
+export { createSandboxCommandModule, SandboxCommandSource } from './sandbox-command-module.js';
+export { executeSandboxCommand, formatSandboxStatus, SANDBOX_MODES } from './sandbox-command.js';

package/src/sandbox/sandbox-command-module.ts

@@ -0,0 +1,56 @@
+import { executeSandboxCommand, SANDBOX_MODES } from './sandbox-command.js';
+
+import type { ICommandModule, ISystemCommand } from '@robota-sdk/agent-framework';
+import type { ICommand, ICommandSource } from '@robota-sdk/agent-interface-command';
+
+const DESCRIPTION = 'Show or change how shell commands are confined';
+const ARGUMENT_HINT = SANDBOX_MODES.map((entry) => entry.mode).join(' | ');
+
+export function createSandboxCommandEntry(): ICommand {
+  return {
+    name: 'sandbox',
+    displayName: 'Sandbox',
+    description: DESCRIPTION,
+    source: 'sandbox',
+    argumentHint: ARGUMENT_HINT,
+    subcommands: SANDBOX_MODES.map(({ mode, description }) => ({
+      name: mode,
+      description,
+      source: 'sandbox',
+    })),
+    // User-only: changes the sandbox boundary; permission widening is the user's.
+    modelInvocable: false,
+  };
+}
+
+function createSandboxSystemCommand(): ISystemCommand {
+  const entry = createSandboxCommandEntry();
+  return {
+    name: entry.name,
+    displayName: entry.displayName,
+    description: entry.description,
+    requiresPermission: false,
+    userInvocable: true,
+    modelInvocable: false,
+    argumentHint: entry.argumentHint,
+    subcommands: entry.subcommands,
+    lifecycle: 'inline',
+    execute: executeSandboxCommand,
+  };
+}
+
+export class SandboxCommandSource implements ICommandSource {
+  readonly name = 'sandbox';
+
+  getCommands(): ICommand[] {
+    return [createSandboxCommandEntry()];
+  }
+}
+
+export function createSandboxCommandModule(): ICommandModule {
+  return {
+    name: 'agent-command-sandbox',
+    commandSources: [new SandboxCommandSource()],
+    systemCommands: [createSandboxSystemCommand()],
+  };
+}

package/src/sandbox/sandbox-command.ts

@@ -0,0 +1,94 @@
+/**
+ * `/sandbox`: see how shell commands are confined and change it (issue #3082).
+ *
+ * The OS sandbox is live — the choice applies to the next command — and is saved in the user
+ * settings so the next session starts the same way.
+ */
+import { selectAction } from '@robota-sdk/agent-core';
+
+import type {
+  ICommandHostAdapterAccess,
+  ICommandHostUserInteraction,
+  ICommandSandboxStatus,
+  TSandboxCommandMode,
+} from '@robota-sdk/agent-framework';
+import type { ICommandResult } from '@robota-sdk/agent-interface-command';
+
+export const SANDBOX_MODES: readonly {
+  readonly mode: TSandboxCommandMode;
+  readonly description: string;
+}[] = [
+  { mode: 'auto-allow', description: 'Confine shell commands; confined ones run without a prompt' },
+  { mode: 'regular', description: 'Confine shell commands; prompts work as usual' },
+  { mode: 'off', description: 'Run shell commands on this machine, unconfined' },
+];
+
+function isSandboxMode(value: string): value is TSandboxCommandMode {
+  return SANDBOX_MODES.some((entry) => entry.mode === value);
+}
+
+export function formatSandboxStatus(status: ICommandSandboxStatus): string {
+  const lines = [
+    `Sandbox: ${status.mode}${status.backend !== undefined ? ` (${status.backend})` : ''}`,
+  ];
+  if (status.unavailable !== undefined) {
+    lines.push(
+      status.mode === 'off'
+        ? `Not available here: ${status.unavailable}.`
+        : `Cannot run here: ${status.unavailable}. Commands run unconfined.`,
+    );
+  }
+  if (status.mode !== 'off' && status.unavailable === undefined) {
+    lines.push(
+      'Writes are limited to the workspace and temp directories; settings and git hooks stay read-only.',
+      `Network: ${status.network ? 'allowed' : 'blocked'}.`,
+    );
+    if (status.excludedCommands.length > 0) {
+      lines.push(`Run unconfined: ${status.excludedCommands.join(', ')}.`);
+    }
+  }
+  return lines.join('\n');
+}
+
+async function askForMode(
+  context: ICommandHostUserInteraction,
+  current: TSandboxCommandMode,
+): Promise<string | undefined> {
+  const ui = context.getUserInteraction();
+  if (!ui) return undefined;
+  const options = SANDBOX_MODES.map(({ mode, description }) => ({
+    value: mode,
+    label: mode === current ? `${mode} (current)` : mode,
+    description,
+  }));
+  const response = await ui.ask(selectAction('sandbox', 'Sandbox mode', options));
+  return response.type === 'answer' ? response.values[0] : undefined;
+}
+
+export async function executeSandboxCommand(
+  context: ICommandHostAdapterAccess & ICommandHostUserInteraction,
+  args: string,
+): Promise<ICommandResult> {
+  const adapter = context.getCommandHostAdapters?.().sandbox;
+  if (adapter === undefined) {
+    return { message: 'This host has no OS sandbox.', success: false };
+  }
+  const before = adapter.status();
+  const requested = args.trim().split(/\s+/)[0] || (await askForMode(context, before.mode));
+  if (requested === undefined || requested === '') {
+    return { message: formatSandboxStatus(before), success: true, data: { ...before } };
+  }
+  if (!isSandboxMode(requested)) {
+    return {
+      message: `Unknown sandbox mode "${requested}". Valid: ${SANDBOX_MODES.map((entry) => entry.mode).join(' | ')}`,
+      success: false,
+    };
+  }
+  adapter.setMode(requested);
+  const after = adapter.status();
+  return {
+    message: `Sandbox mode set to: ${requested}\n${formatSandboxStatus(after)}`,
+    success: true,
+    data: { ...after },
+  };
+}