start-command 0.13.0 → 0.16.0

package/test/isolation-cleanup.test.js

@@ -238,22 +238,15 @@ describe('Isolation Resource Cleanup Verification', () => {
   });
 
   describe('docker resource cleanup', () => {
-    // Helper function to check if docker daemon is running
-    function isDockerRunning() {
-      if (!isCommandAvailable('docker')) {
-        return false;
-      }
-      try {
-        execSync('docker info', { stdio: 'ignore', timeout: 5000 });
-        return true;
-      } catch {
-        return false;
-      }
-    }
+    // Use the canRunLinuxDockerImages function from isolation module
+    // to properly detect if Linux containers can run (handles Windows containers mode)
+    const { canRunLinuxDockerImages } = require('../src/lib/isolation');
 
     it('should show docker container as exited after command completes (auto-exit by default)', async () => {
-      if (!isDockerRunning()) {
-        console.log('  Skipping: docker not available or daemon not running');
+      if (!canRunLinuxDockerImages()) {
+        console.log(
+          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+        );
         return;
       }
 
@@ -325,8 +318,10 @@ describe('Isolation Resource Cleanup Verification', () => {
     });
 
     it('should keep docker container running when keepAlive is true', async () => {
-      if (!isDockerRunning()) {
-        console.log('  Skipping: docker not available or daemon not running');
+      if (!canRunLinuxDockerImages()) {
+        console.log(
+          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+        );
         return;
       }
 

package/test/isolation.test.js

@@ -444,23 +444,15 @@ describe('Isolation Keep-Alive Behavior', () => {
   });
 
   describe('runInDocker keep-alive messages', () => {
-    // Helper function to check if docker daemon is running
-    function isDockerRunning() {
-      if (!isCommandAvailable('docker')) {
-        return false;
-      }
-      try {
-        // Try to ping the docker daemon
-        execSync('docker info', { stdio: 'ignore', timeout: 5000 });
-        return true;
-      } catch {
-        return false;
-      }
-    }
+    // Use the canRunLinuxDockerImages function from isolation module
+    // to properly detect if Linux containers can run (handles Windows containers mode)
+    const { canRunLinuxDockerImages } = require('../src/lib/isolation');
 
     it('should include auto-exit message by default in detached mode', async () => {
-      if (!isDockerRunning()) {
-        console.log('  Skipping: docker not available or daemon not running');
+      if (!canRunLinuxDockerImages()) {
+        console.log(
+          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+        );
         return;
       }
 
@@ -487,8 +479,10 @@ describe('Isolation Keep-Alive Behavior', () => {
     });
 
     it('should include keep-alive message when keepAlive is true', async () => {
-      if (!isDockerRunning()) {
-        console.log('  Skipping: docker not available or daemon not running');
+      if (!canRunLinuxDockerImages()) {
+        console.log(
+          '  Skipping: docker not available, daemon not running, or Linux containers not supported'
+        );
         return;
       }
 

package/test/output-blocks.test.js

@@ -0,0 +1,197 @@
+/**
+ * Tests for output-blocks module
+ */
+
+const { describe, it, expect } = require('bun:test');
+
+const {
+  BOX_STYLES,
+  DEFAULT_STYLE,
+  DEFAULT_WIDTH,
+  getBoxStyle,
+  createStartBlock,
+  createFinishBlock,
+  formatDuration,
+  escapeForLinksNotation,
+  formatAsNestedLinksNotation,
+} = require('../src/lib/output-blocks');
+
+describe('output-blocks module', () => {
+  describe('BOX_STYLES', () => {
+    it('should have all expected styles', () => {
+      expect(BOX_STYLES).toHaveProperty('rounded');
+      expect(BOX_STYLES).toHaveProperty('heavy');
+      expect(BOX_STYLES).toHaveProperty('double');
+      expect(BOX_STYLES).toHaveProperty('simple');
+      expect(BOX_STYLES).toHaveProperty('ascii');
+    });
+
+    it('should have correct rounded style characters', () => {
+      expect(BOX_STYLES.rounded.topLeft).toBe('╭');
+      expect(BOX_STYLES.rounded.topRight).toBe('╮');
+      expect(BOX_STYLES.rounded.bottomLeft).toBe('╰');
+      expect(BOX_STYLES.rounded.bottomRight).toBe('╯');
+    });
+  });
+
+  describe('getBoxStyle', () => {
+    it('should return rounded style by default', () => {
+      const style = getBoxStyle();
+      expect(style).toEqual(BOX_STYLES.rounded);
+    });
+
+    it('should return requested style', () => {
+      expect(getBoxStyle('heavy')).toEqual(BOX_STYLES.heavy);
+      expect(getBoxStyle('double')).toEqual(BOX_STYLES.double);
+      expect(getBoxStyle('ascii')).toEqual(BOX_STYLES.ascii);
+    });
+
+    it('should return rounded for unknown style', () => {
+      const style = getBoxStyle('unknown');
+      expect(style).toEqual(BOX_STYLES.rounded);
+    });
+  });
+
+  describe('createStartBlock', () => {
+    it('should create a start block with session ID', () => {
+      const block = createStartBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:00',
+        command: 'echo hello',
+      });
+
+      expect(block).toContain('╭');
+      expect(block).toContain('╰');
+      expect(block).toContain('Session ID: test-uuid-1234');
+      expect(block).toContain('Starting at 2025-01-01 00:00:00: echo hello');
+    });
+
+    it('should use specified style', () => {
+      const block = createStartBlock({
+        sessionId: 'test-uuid',
+        timestamp: '2025-01-01 00:00:00',
+        command: 'echo hello',
+        style: 'ascii',
+      });
+
+      expect(block).toContain('+');
+      expect(block).toContain('-');
+    });
+  });
+
+  describe('createFinishBlock', () => {
+    it('should create a finish block with session ID and exit code', () => {
+      const block = createFinishBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:01',
+        exitCode: 0,
+        logPath: '/tmp/test.log',
+        durationMs: 17,
+      });
+
+      expect(block).toContain('╭');
+      expect(block).toContain('╰');
+      expect(block).toContain('Session ID: test-uuid-1234');
+      expect(block).toContain(
+        'Finished at 2025-01-01 00:00:01 in 0.017 seconds'
+      );
+      expect(block).toContain('Exit code: 0');
+      expect(block).toContain('Log: /tmp/test.log');
+    });
+
+    it('should create a finish block without duration when not provided', () => {
+      const block = createFinishBlock({
+        sessionId: 'test-uuid-1234',
+        timestamp: '2025-01-01 00:00:01',
+        exitCode: 0,
+        logPath: '/tmp/test.log',
+      });
+
+      expect(block).toContain('Finished at 2025-01-01 00:00:01');
+      expect(block).not.toContain('seconds');
+    });
+  });
+
+  describe('formatDuration', () => {
+    it('should format very small durations', () => {
+      expect(formatDuration(0.5)).toBe('0.001');
+    });
+
+    it('should format millisecond durations', () => {
+      expect(formatDuration(17)).toBe('0.017');
+      expect(formatDuration(500)).toBe('0.500');
+    });
+
+    it('should format second durations', () => {
+      expect(formatDuration(1000)).toBe('1.000');
+      expect(formatDuration(5678)).toBe('5.678');
+    });
+
+    it('should format longer durations with less precision', () => {
+      expect(formatDuration(12345)).toBe('12.35');
+      expect(formatDuration(123456)).toBe('123.5');
+    });
+  });
+
+  describe('escapeForLinksNotation', () => {
+    it('should not quote simple values', () => {
+      expect(escapeForLinksNotation('simple')).toBe('simple');
+      expect(escapeForLinksNotation('123')).toBe('123');
+      expect(escapeForLinksNotation('true')).toBe('true');
+    });
+
+    it('should quote values with spaces', () => {
+      expect(escapeForLinksNotation('hello world')).toBe('"hello world"');
+    });
+
+    it('should quote values with colons', () => {
+      expect(escapeForLinksNotation('key:value')).toBe('"key:value"');
+    });
+
+    it('should use single quotes for values with double quotes', () => {
+      expect(escapeForLinksNotation('say "hello"')).toBe('\'say "hello"\'');
+    });
+
+    it('should use double quotes for values with single quotes', () => {
+      expect(escapeForLinksNotation("it's cool")).toBe('"it\'s cool"');
+    });
+
+    it('should escape quotes when both types are present', () => {
+      const result = escapeForLinksNotation('say "hello" it\'s');
+      // Should wrap in one quote type and escape the other
+      expect(result).toMatch(/^["'].*["']$/);
+    });
+
+    it('should handle null values', () => {
+      expect(escapeForLinksNotation(null)).toBe('null');
+      expect(escapeForLinksNotation(undefined)).toBe('null');
+    });
+  });
+
+  describe('formatAsNestedLinksNotation', () => {
+    it('should format simple objects', () => {
+      const obj = { key: 'value', number: 123 };
+      const result = formatAsNestedLinksNotation(obj);
+
+      expect(result).toContain('key value');
+      expect(result).toContain('number 123');
+    });
+
+    it('should quote values with spaces', () => {
+      const obj = { message: 'hello world' };
+      const result = formatAsNestedLinksNotation(obj);
+
+      expect(result).toContain('message "hello world"');
+    });
+
+    it('should handle empty objects', () => {
+      expect(formatAsNestedLinksNotation({})).toBe('()');
+    });
+
+    it('should handle null', () => {
+      expect(formatAsNestedLinksNotation(null)).toBe('null');
+    });
+  });
+});
+
+console.log('=== Output Blocks Unit Tests ===');

package/test/public-exports.test.js

@@ -0,0 +1,105 @@
+/**
+ * Tests for public exports of start-command package
+ * Verifies that ExecutionStore can be imported via package exports
+ */
+
+const { describe, it, expect } = require('bun:test');
+
+describe('Public Exports', () => {
+  describe('execution-store export', () => {
+    it('should export ExecutionStore class', () => {
+      const { ExecutionStore } = require('../src/lib/execution-store');
+      expect(ExecutionStore).toBeDefined();
+      expect(typeof ExecutionStore).toBe('function');
+    });
+
+    it('should export ExecutionRecord class', () => {
+      const { ExecutionRecord } = require('../src/lib/execution-store');
+      expect(ExecutionRecord).toBeDefined();
+      expect(typeof ExecutionRecord).toBe('function');
+    });
+
+    it('should export ExecutionStatus enum', () => {
+      const { ExecutionStatus } = require('../src/lib/execution-store');
+      expect(ExecutionStatus).toBeDefined();
+      expect(ExecutionStatus.EXECUTING).toBe('executing');
+      expect(ExecutionStatus.EXECUTED).toBe('executed');
+    });
+
+    it('should export LockManager class', () => {
+      const { LockManager } = require('../src/lib/execution-store');
+      expect(LockManager).toBeDefined();
+      expect(typeof LockManager).toBe('function');
+    });
+
+    it('should export isClinkInstalled function', () => {
+      const { isClinkInstalled } = require('../src/lib/execution-store');
+      expect(isClinkInstalled).toBeDefined();
+      expect(typeof isClinkInstalled).toBe('function');
+    });
+
+    it('should export configuration constants', () => {
+      const {
+        DEFAULT_APP_FOLDER,
+        LINO_DB_FILE,
+        LINKS_DB_FILE,
+        LOCK_FILE,
+      } = require('../src/lib/execution-store');
+      expect(DEFAULT_APP_FOLDER).toBeDefined();
+      expect(typeof DEFAULT_APP_FOLDER).toBe('string');
+      expect(LINO_DB_FILE).toBe('executions.lino');
+      expect(LINKS_DB_FILE).toBe('executions.links');
+      expect(LOCK_FILE).toBe('executions.lock');
+    });
+
+    it('should allow creating and using ExecutionStore instance', () => {
+      const os = require('os');
+      const path = require('path');
+      const fs = require('fs');
+
+      const {
+        ExecutionStore,
+        ExecutionRecord,
+        ExecutionStatus,
+      } = require('../src/lib/execution-store');
+
+      // Create a temporary folder for testing
+      const testFolder = path.join(
+        os.tmpdir(),
+        `public-export-test-${Date.now()}`
+      );
+
+      try {
+        const store = new ExecutionStore({ appFolder: testFolder });
+        expect(store).toBeDefined();
+
+        // Create and save a record
+        const record = new ExecutionRecord({
+          command: 'echo "test"',
+          logPath: '/tmp/test.log',
+        });
+        expect(record.status).toBe(ExecutionStatus.EXECUTING);
+
+        store.save(record);
+
+        // Retrieve the record
+        const retrieved = store.get(record.uuid);
+        expect(retrieved).toBeDefined();
+        expect(retrieved.command).toBe('echo "test"');
+
+        // Complete the record
+        record.complete(0);
+        store.save(record);
+
+        const completed = store.get(record.uuid);
+        expect(completed.status).toBe(ExecutionStatus.EXECUTED);
+        expect(completed.exitCode).toBe(0);
+      } finally {
+        // Cleanup
+        if (fs.existsSync(testFolder)) {
+          fs.rmSync(testFolder, { recursive: true, force: true });
+        }
+      }
+    });
+  });
+});

package/test/status-query.test.js

@@ -0,0 +1,197 @@
+/**
+ * Integration tests for --status query functionality
+ */
+
+const { describe, it, expect, beforeEach, afterEach } = require('bun:test');
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const {
+  ExecutionStore,
+  ExecutionRecord,
+  ExecutionStatus,
+} = require('../src/lib/execution-store');
+
+// Use temp directory for tests
+const TEST_APP_FOLDER = path.join(
+  os.tmpdir(),
+  `status-query-test-${Date.now()}`
+);
+
+// Path to CLI
+const CLI_PATH = path.join(__dirname, '../src/bin/cli.js');
+
+// Helper to clean up test directory
+function cleanupTestDir() {
+  if (fs.existsSync(TEST_APP_FOLDER)) {
+    fs.rmSync(TEST_APP_FOLDER, { recursive: true, force: true });
+  }
+}
+
+// Helper to run CLI command
+function runCli(args, env = {}) {
+  const result = spawnSync('bun', [CLI_PATH, ...args], {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      START_APP_FOLDER: TEST_APP_FOLDER,
+      ...env,
+    },
+    timeout: 10000,
+  });
+  return {
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    exitCode: result.status,
+  };
+}
+
+describe('--status query functionality', () => {
+  let store;
+  let testRecord;
+
+  beforeEach(() => {
+    cleanupTestDir();
+    store = new ExecutionStore({
+      appFolder: TEST_APP_FOLDER,
+      useLinks: false,
+    });
+
+    // Create a test execution record
+    testRecord = new ExecutionRecord({
+      command: 'echo hello world',
+      pid: 12345,
+      logPath: '/tmp/test.log',
+      workingDirectory: '/home/test',
+      shell: '/bin/bash',
+    });
+    testRecord.complete(0);
+    store.save(testRecord);
+  });
+
+  afterEach(() => {
+    cleanupTestDir();
+  });
+
+  describe('links-notation format (default)', () => {
+    it('should output status in links-notation indented format by default', () => {
+      const result = runCli(['--status', testRecord.uuid]);
+
+      expect(result.exitCode).toBe(0);
+      // Should start with UUID on its own line
+      expect(result.stdout).toMatch(new RegExp(`^${testRecord.uuid}\\n`));
+      // Should have indented properties (values without special chars are not quoted)
+      expect(result.stdout).toContain(`  uuid ${testRecord.uuid}`);
+      expect(result.stdout).toContain('  status executed');
+      // Command with space should be quoted
+      expect(result.stdout).toContain('  command "echo hello world"');
+    });
+
+    it('should output status in links-notation format with explicit flag', () => {
+      const result = runCli([
+        '--status',
+        testRecord.uuid,
+        '--output-format',
+        'links-notation',
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      // Should start with UUID on its own line
+      expect(result.stdout).toMatch(new RegExp(`^${testRecord.uuid}\\n`));
+      // UUID without special chars is not quoted
+      expect(result.stdout).toContain(`  uuid ${testRecord.uuid}`);
+    });
+  });
+
+  describe('json format', () => {
+    it('should output status in JSON format', () => {
+      const result = runCli([
+        '--status',
+        testRecord.uuid,
+        '--output-format',
+        'json',
+      ]);
+
+      expect(result.exitCode).toBe(0);
+
+      // Parse the JSON output
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.uuid).toBe(testRecord.uuid);
+      expect(parsed.command).toBe('echo hello world');
+      expect(parsed.status).toBe('executed');
+      expect(parsed.exitCode).toBe(0);
+      expect(parsed.pid).toBe(12345);
+    });
+  });
+
+  describe('text format', () => {
+    it('should output status in human-readable text format', () => {
+      const result = runCli([
+        '--status',
+        testRecord.uuid,
+        '--output-format',
+        'text',
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toContain('Execution Status');
+      expect(result.stdout).toContain('UUID:');
+      expect(result.stdout).toContain(testRecord.uuid);
+      expect(result.stdout).toContain('Status:');
+      expect(result.stdout).toContain('executed');
+      expect(result.stdout).toContain('Command:');
+      expect(result.stdout).toContain('echo hello world');
+      expect(result.stdout).toContain('Exit Code:');
+      expect(result.stdout).toContain('0');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should show error for non-existent UUID', () => {
+      const fakeUuid = '00000000-0000-0000-0000-000000000000';
+      const result = runCli(['--status', fakeUuid]);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain('No execution found with UUID');
+      expect(result.stderr).toContain(fakeUuid);
+    });
+
+    it('should show error when tracking is disabled', () => {
+      const result = runCli(['--status', testRecord.uuid], {
+        START_DISABLE_TRACKING: '1',
+      });
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toContain('tracking is disabled');
+    });
+  });
+
+  describe('executing status', () => {
+    it('should show executing status for ongoing commands', () => {
+      // Create an executing (not completed) record
+      const executingRecord = new ExecutionRecord({
+        command: 'sleep 100',
+        pid: 99999,
+        logPath: '/tmp/executing.log',
+      });
+      store.save(executingRecord);
+
+      const result = runCli([
+        '--status',
+        executingRecord.uuid,
+        '--output-format',
+        'json',
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      const parsed = JSON.parse(result.stdout);
+      expect(parsed.status).toBe('executing');
+      expect(parsed.exitCode).toBeNull();
+      expect(parsed.endTime).toBeNull();
+    });
+  });
+});
+
+console.log('=== Status Query Integration Tests ===');