atcoder-workspace 1.1.0-beta.1

package/src/session/auth.ts

@@ -0,0 +1,87 @@
+import * as cheerio from 'cheerio';
+import { saveSession, loadSession, SavedCookie } from './store';
+import { createAtCoderClient } from '../atcoder/client';
+import { AuthError } from '../utils/errors';
+
+/**
+ * Saves a manually entered REVEL_SESSION cookie and verifies the session.
+ */
+export async function loginWithCookie(workspaceRoot: string, revelSession: string): Promise<string> {
+  let cleanSession = revelSession.trim();
+  if (!cleanSession) {
+    throw new AuthError('REVEL_SESSION cookie value cannot be empty.');
+  }
+
+  if (cleanSession.startsWith('REVEL_SESSION=')) {
+    cleanSession = cleanSession.substring('REVEL_SESSION='.length);
+  }
+  cleanSession = cleanSession.split(';')[0].trim();
+
+  if (!cleanSession) {
+    throw new AuthError('Could not extract a valid REVEL_SESSION value.');
+  }
+
+  const savedCookies: SavedCookie[] = [
+    {
+      name: 'REVEL_SESSION',
+      value: cleanSession,
+      domain: '.atcoder.jp',
+      path: '/',
+      expires: Math.floor(Date.now() / 1000) + 86400 * 30,
+      httpOnly: true,
+      secure: true,
+      sameSite: 'Lax'
+    }
+  ];
+
+  saveSession(workspaceRoot, savedCookies);
+
+  try {
+    const username = await whoami(workspaceRoot);
+    return username;
+  } catch (err: any) {
+    try {
+      const { clearSession } = require('./store');
+      clearSession(workspaceRoot);
+    } catch (e) {}
+    throw new AuthError(`The provided REVEL_SESSION cookie is invalid or expired: ${err.message}`);
+  }
+}
+
+/**
+ * Checks the login status by requesting the AtCoder settings page with saved session cookies.
+ */
+export async function whoami(workspaceRoot: string): Promise<string> {
+  const session = loadSession(workspaceRoot);
+  if (!session || !session.some(c => c.name === 'REVEL_SESSION')) {
+    throw new AuthError('No active session. Please log in using "atc login".');
+  }
+
+  const client = createAtCoderClient(workspaceRoot);
+  try {
+    const res = await client.get('/settings');
+    const $ = cheerio.load(res.data);
+    
+    const userLink = $('header a[href^="/users/"], .navbar-right a[href^="/users/"]').first();
+    const href = userLink.attr('href');
+    if (href) {
+      const match = href.match(/\/users\/([a-zA-Z0-9_]+)/);
+      if (match && match[1]) {
+        return match[1];
+      }
+    }
+
+    const usernameSpan = $('header a.username, header .dropdown-toggle').first();
+    if (usernameSpan.length) {
+      const name = usernameSpan.text().replace(/\s+/g, ' ').trim();
+      if (name && name !== 'Sign In' && name !== 'ログイン' && name !== 'Sign Up' && name !== '新規登録') {
+        return name;
+      }
+    }
+
+    throw new AuthError('Session is invalid or expired.');
+  } catch (err: any) {
+    if (err instanceof AuthError) throw err;
+    throw new AuthError(`Failed to verify session: ${err.message}`);
+  }
+}

package/src/session/store.ts

@@ -0,0 +1,50 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export interface SavedCookie {
+  name: string;
+  value: string;
+  domain: string;
+  path: string;
+  expires: number;
+  httpOnly: boolean;
+  secure: boolean;
+  sameSite: 'Strict' | 'Lax' | 'None';
+}
+
+export function getSessionPath(workspaceRoot: string): string {
+  return path.join(workspaceRoot, '.atcoder-cli', 'session.json');
+}
+
+export function saveSession(workspaceRoot: string, cookies: SavedCookie[]): void {
+  const sessionPath = getSessionPath(workspaceRoot);
+  const dir = path.dirname(sessionPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(sessionPath, JSON.stringify(cookies, null, 2), 'utf8');
+}
+
+export function loadSession(workspaceRoot: string): SavedCookie[] | null {
+  const sessionPath = getSessionPath(workspaceRoot);
+  if (!fs.existsSync(sessionPath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(sessionPath, 'utf8');
+    return JSON.parse(raw) as SavedCookie[];
+  } catch (e) {
+    return null;
+  }
+}
+
+export function clearSession(workspaceRoot: string): void {
+  const sessionPath = getSessionPath(workspaceRoot);
+  if (fs.existsSync(sessionPath)) {
+    fs.unlinkSync(sessionPath);
+  }
+}
+
+export function getCookieHeaderString(cookies: SavedCookie[]): string {
+  return cookies.map(c => `${c.name}=${c.value}`).join('; ');
+}

package/src/test-runner/diff.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest';
+import { compareOutput } from './diff';
+
+describe('compareOutput', () => {
+  it('should match identical strings', () => {
+    const res = compareOutput('hello\nworld', 'hello\nworld');
+    expect(res.isMatch).toBe(true);
+  });
+
+  it('should ignore trailing space and newlines', () => {
+    const res = compareOutput('hello   \nworld\n\n', 'hello\nworld');
+    expect(res.isMatch).toBe(true);
+  });
+
+  it('should detect mismatch and identify line number', () => {
+    const res = compareOutput('hello\nworld', 'hello\nthere');
+    expect(res.isMatch).toBe(false);
+    expect(res.firstDiffLine).toBe(2);
+  });
+
+  it('should handle extra lines', () => {
+    const res = compareOutput('hello\nworld\nmore', 'hello\nworld');
+    expect(res.isMatch).toBe(false);
+    expect(res.firstDiffLine).toBe(3);
+  });
+});

package/src/test-runner/diff.ts

@@ -0,0 +1,42 @@
+export interface CompareResult {
+  isMatch: boolean;
+  actualNormalized: string;
+  expectedNormalized: string;
+  firstDiffLine?: number; // 1-indexed
+}
+
+export function compareOutput(actual: string, expected: string): CompareResult {
+  const actualLines = normalizeAndSplit(actual);
+  const expectedLines = normalizeAndSplit(expected);
+
+  let isMatch = true;
+  let firstDiffLine: number | undefined;
+
+  const maxLines = Math.max(actualLines.length, expectedLines.length);
+  for (let i = 0; i < maxLines; i++) {
+    if (actualLines[i] !== expectedLines[i]) {
+      isMatch = false;
+      firstDiffLine = i + 1;
+      break;
+    }
+  }
+
+  return {
+    isMatch,
+    actualNormalized: actualLines.join('\n'),
+    expectedNormalized: expectedLines.join('\n'),
+    firstDiffLine
+  };
+}
+
+function normalizeAndSplit(str: string): string[] {
+  const lines = str.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+  const trimmed = lines.map(line => line.trimEnd());
+  
+  // Remove trailing empty lines
+  while (trimmed.length > 0 && trimmed[trimmed.length - 1] === '') {
+    trimmed.pop();
+  }
+  
+  return trimmed;
+}

package/src/test-runner/runner.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi } from 'vitest';
+import * as path from 'path';
+import * as fs from 'fs';
+import { resolveCommands, resolveTaskDirectory } from './runner';
+import * as configStore from '../config/config-store';
+
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('fs')>();
+  return {
+    ...actual,
+    existsSync: vi.fn((p: any) => {
+      if (p.toString().endsWith('my-contests/abc300/a')) {
+        return true;
+      }
+      return actual.existsSync(p);
+    }),
+    statSync: vi.fn((p: any) => {
+      if (p.toString().endsWith('my-contests/abc300/a')) {
+        return { isDirectory: () => true } as any;
+      }
+      return actual.statSync(p);
+    }),
+  };
+});
+
+describe('runner utils', () => {
+  describe('resolveCommands', () => {
+    it('should substitute template file names correctly', () => {
+      const langConfig = {
+        extension: 'cpp',
+        templateDir: 'templates/cpp',
+        build: 'g++ -O2 -std=gnu++20 -o a.out main.cpp',
+        run: './a.out'
+      };
+
+      const resolved = resolveCommands('/workspace', langConfig, 'sol.cpp', 'cpp');
+      expect(resolved.build).toBe('g++ -O2 -std=gnu++20 -o a.out sol.cpp');
+      expect(resolved.run).toBe('./a.out');
+    });
+
+    it('should handle languages without build commands', () => {
+      const langConfig = {
+        extension: 'py',
+        templateDir: 'templates/python',
+        build: '',
+        run: 'python3 main.py'
+      };
+
+      const resolved = resolveCommands('/workspace', langConfig, 'sol.py', 'py');
+      expect(resolved.build).toBe('');
+      expect(resolved.run).toBe('python3 sol.py');
+    });
+  });
+
+  describe('resolveTaskDirectory', () => {
+    it('should resolve task directory under configured contestDir', () => {
+      const loadConfigSpy = vi.spyOn(configStore, 'loadConfig').mockReturnValue({
+        defaultLanguage: 'cpp',
+        languages: {},
+        testDirName: 'tests',
+        contestDir: 'my-contests'
+      });
+
+      const resolved = resolveTaskDirectory('/workspace', 'abc300/a');
+      expect(resolved).toContain('my-contests/abc300/a');
+
+      loadConfigSpy.mockRestore();
+    });
+  });
+});

package/src/test-runner/runner.ts

@@ -0,0 +1,315 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn, exec } from 'child_process';
+import { findWorkspaceRoot } from '../workspace/finder';
+import { loadConfig, Config, LanguageConfig } from '../config/config-store';
+import { compareOutput } from './diff';
+import { AtcError } from '../utils/errors';
+
+export interface TestCaseResult {
+  index: number;
+  status: 'AC' | 'WA' | 'TLE' | 'RE';
+  durationMs: number;
+  actualOutput: string;
+  expectedOutput: string;
+  errorOutput?: string;
+  firstDiffLine?: number;
+}
+
+export interface RunAllTestsResult {
+  success: boolean;
+  compileError?: string;
+  results: TestCaseResult[];
+}
+
+/**
+ * Resolves the absolute path to a task directory.
+ */
+export function resolveTaskDirectory(workspaceRoot: string, taskArg?: string): string {
+  const cwd = process.cwd();
+  
+  if (taskArg) {
+    const pathFromCwd = path.resolve(cwd, taskArg);
+    if (fs.existsSync(pathFromCwd) && fs.statSync(pathFromCwd).isDirectory()) {
+      return pathFromCwd;
+    }
+    
+    const pathFromRoot = path.resolve(workspaceRoot, taskArg);
+    if (fs.existsSync(pathFromRoot) && fs.statSync(pathFromRoot).isDirectory()) {
+      return pathFromRoot;
+    }
+
+    const config = loadConfig(workspaceRoot);
+    if (config.contestDir) {
+      const pathFromConfigDir = path.resolve(workspaceRoot, config.contestDir, taskArg);
+      if (fs.existsSync(pathFromConfigDir) && fs.statSync(pathFromConfigDir).isDirectory()) {
+        return pathFromConfigDir;
+      }
+    }
+
+    const labelPath = path.join(cwd, taskArg);
+    if (fs.existsSync(labelPath) && fs.statSync(labelPath).isDirectory()) {
+      return labelPath;
+    }
+
+    throw new AtcError(`Task directory "${taskArg}" not found.`);
+  }
+
+  if (path.resolve(cwd) === path.resolve(workspaceRoot)) {
+    throw new AtcError('You are in the workspace root. Please specify a task directory (e.g., "atc test abc300/a").');
+  }
+
+  return cwd;
+}
+
+/**
+ * Detects the code file to execute in the task directory.
+ */
+export function detectCodeFile(
+  workspaceRoot: string,
+  taskDir: string,
+  config: Config,
+  fileArg?: string
+): { codeFile: string; langKey: string; langConfig: LanguageConfig } {
+  if (fileArg) {
+    const fullPath = path.resolve(taskDir, fileArg);
+    if (!fs.existsSync(fullPath)) {
+      throw new AtcError(`Specified source file "${fileArg}" not found in "${taskDir}"`);
+    }
+    
+    const ext = path.extname(fileArg).slice(1);
+    for (const [key, langConfig] of Object.entries(config.languages)) {
+      if (langConfig.extension === ext) {
+        return { codeFile: fileArg, langKey: key, langConfig };
+      }
+    }
+    throw new AtcError(`No language configuration found for file extension ".${ext}"`);
+  }
+
+  const files = fs.readdirSync(taskDir);
+  
+  const defLang = config.languages[config.defaultLanguage];
+  if (defLang) {
+    const matchedFile = files.find(f => f.endsWith(`.${defLang.extension}`) && fs.statSync(path.join(taskDir, f)).isFile());
+    if (matchedFile) {
+      return { codeFile: matchedFile, langKey: config.defaultLanguage, langConfig: defLang };
+    }
+  }
+
+  for (const [key, langConfig] of Object.entries(config.languages)) {
+    if (key === config.defaultLanguage) continue;
+    const matchedFile = files.find(f => f.endsWith(`.${langConfig.extension}`) && fs.statSync(path.join(taskDir, f)).isFile());
+    if (matchedFile) {
+      return { codeFile: matchedFile, langKey: key, langConfig };
+    }
+  }
+
+  throw new AtcError(`No source files found in "${taskDir}" matching configured languages.`);
+}
+
+/**
+ * Resolves the build and run commands by substituting template filenames with the actual filename.
+ */
+export function resolveCommands(
+  workspaceRoot: string,
+  langConfig: LanguageConfig,
+  actualFile: string,
+  extension: string
+): { build: string; run: string } {
+  const templateDir = langConfig.templateDir;
+  let templateFileName = `main.${extension}`;
+  
+  const fullTemplatePath = path.join(workspaceRoot, '.atcoder-cli', templateDir);
+  if (fs.existsSync(fullTemplatePath) && fs.statSync(fullTemplatePath).isDirectory()) {
+    const files = fs.readdirSync(fullTemplatePath);
+    const matched = files.find(f => f.endsWith(`.${extension}`));
+    if (matched) {
+      templateFileName = matched;
+    }
+  }
+
+  const escapedTemplateName = templateFileName.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+  const regex = new RegExp(escapedTemplateName, 'g');
+
+  const resolvedBuild = langConfig.build.replace(regex, actualFile);
+  const resolvedRun = langConfig.run.replace(regex, actualFile);
+
+  return {
+    build: resolvedBuild,
+    run: resolvedRun
+  };
+}
+
+/**
+ * Runs the build command if present.
+ */
+export function runBuild(buildCommand: string, taskDir: string): Promise<{ code: number; stderr: string }> {
+  return new Promise((resolve) => {
+    exec(buildCommand, { cwd: taskDir }, (err, stdout, stderr) => {
+      resolve({
+        code: err ? (err.code ?? 1) : 0,
+        stderr: stderr || stdout
+      });
+    });
+  });
+}
+
+/**
+ * Runs a single test case.
+ */
+export function runTestCase(
+  runCommand: string,
+  taskDir: string,
+  inputPath: string,
+  outputPath: string,
+  timeLimitMs: number,
+  index: number
+): Promise<TestCaseResult> {
+  return new Promise((resolve) => {
+    const input = fs.readFileSync(inputPath, 'utf8');
+    const expected = fs.readFileSync(outputPath, 'utf8');
+    
+    const startTime = process.hrtime.bigint();
+    
+    const child = spawn(runCommand, {
+      cwd: taskDir,
+      shell: true
+    });
+    
+    let stdout = '';
+    let stderr = '';
+    let killedByTimeout = false;
+    
+    const timer = setTimeout(() => {
+      killedByTimeout = true;
+      child.kill('SIGKILL');
+    }, timeLimitMs);
+    
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+    
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      const endTime = process.hrtime.bigint();
+      const durationMs = Number(endTime - startTime) / 1e6;
+      resolve({
+        index,
+        status: 'RE',
+        durationMs,
+        actualOutput: stdout,
+        expectedOutput: expected,
+        errorOutput: err.message
+      });
+    });
+    
+    child.on('exit', (code, signal) => {
+      clearTimeout(timer);
+      const endTime = process.hrtime.bigint();
+      const durationMs = Number(endTime - startTime) / 1e6;
+      
+      if (killedByTimeout || signal === 'SIGKILL') {
+        resolve({
+          index,
+          status: 'TLE',
+          durationMs,
+          actualOutput: stdout,
+          expectedOutput: expected,
+          errorOutput: 'Time Limit Exceeded'
+        });
+        return;
+      }
+      
+      if (code !== 0) {
+        resolve({
+          index,
+          status: 'RE',
+          durationMs,
+          actualOutput: stdout,
+          expectedOutput: expected,
+          errorOutput: stderr || `Exit code ${code}`
+        });
+        return;
+      }
+      
+      const comp = compareOutput(stdout, expected);
+      resolve({
+        index,
+        status: comp.isMatch ? 'AC' : 'WA',
+        durationMs,
+        actualOutput: stdout,
+        expectedOutput: expected,
+        firstDiffLine: comp.firstDiffLine
+      });
+    });
+    
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+
+export async function runAllTests(
+  workspaceRoot: string,
+  taskDir: string,
+  fileArg?: string,
+  timeLimitMs: number = 2000
+): Promise<RunAllTestsResult> {
+  const config = loadConfig(workspaceRoot);
+  const { codeFile, langConfig } = detectCodeFile(workspaceRoot, taskDir, config, fileArg);
+  const { build, run } = resolveCommands(workspaceRoot, langConfig, codeFile, langConfig.extension);
+
+  if (build.trim() !== '') {
+    const buildRes = await runBuild(build, taskDir);
+    if (buildRes.code !== 0) {
+      return {
+        success: false,
+        compileError: buildRes.stderr,
+        results: []
+      };
+    }
+  }
+
+  const testDirName = config.testDirName || 'tests';
+  const testDir = path.join(taskDir, testDirName);
+  
+  if (!fs.existsSync(testDir) || !fs.statSync(testDir).isDirectory()) {
+    throw new AtcError(`Test directory "${testDir}" not found.`);
+  }
+
+  const files = fs.readdirSync(testDir);
+  const inFiles = files.filter(f => f.startsWith('sample-') && f.endsWith('.in'));
+  
+  const results: TestCaseResult[] = [];
+  
+  inFiles.sort((a, b) => {
+    const aIdx = parseInt(a.match(/sample-(\d+)\.in/)![1], 10);
+    const bIdx = parseInt(b.match(/sample-(\d+)\.in/)![1], 10);
+    return aIdx - bIdx;
+  });
+
+  for (const inFile of inFiles) {
+    const match = inFile.match(/sample-(\d+)\.in/);
+    if (!match) continue;
+    const index = parseInt(match[1], 10);
+    const inputPath = path.join(testDir, inFile);
+    const outputPath = path.join(testDir, `sample-${index}.out`);
+
+    if (!fs.existsSync(outputPath)) {
+      continue;
+    }
+
+    const testRes = await runTestCase(run, taskDir, inputPath, outputPath, timeLimitMs, index);
+    results.push(testRes);
+  }
+
+  const success = results.length > 0 && results.every(r => r.status === 'AC');
+
+  return {
+    success,
+    results
+  };
+}

package/src/utils/errors.ts

@@ -0,0 +1,31 @@
+export class AtcError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+export class WorkspaceNotFoundError extends AtcError {
+  constructor() {
+    super('.atcoder-cli/ directory was not found. Please run "atc init" in your workspace root first.');
+  }
+}
+
+export class AuthError extends AtcError {
+  constructor(message: string) {
+    super(`Authentication failed: ${message}`);
+  }
+}
+
+export class ParseError extends AtcError {
+  constructor(message: string) {
+    super(`Parsing failed: ${message}`);
+  }
+}
+
+export class TestError extends AtcError {
+  constructor(message: string) {
+    super(`Test execution failed: ${message}`);
+  }
+}

package/src/utils/format.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { formatOutputLines, formatErrorOutputLines } from './format';
+import pc from 'picocolors';
+
+describe('format utilities', () => {
+  describe('formatOutputLines', () => {
+    it('should format normal lines with line numbers and gray borders', () => {
+      const output = 'line1\nline2\n';
+      const formatted = formatOutputLines(output);
+      
+      expect(formatted).toHaveLength(2);
+      expect(formatted[0]).toContain('1');
+      expect(formatted[0]).toContain('line1');
+      expect(formatted[1]).toContain('2');
+      expect(formatted[1]).toContain('line2');
+    });
+
+    it('should highlight the mismatch line if specified', () => {
+      const output = 'line1\nline2\nline3';
+      const formatted = formatOutputLines(output, 2);
+      
+      expect(formatted).toHaveLength(3);
+      // Line 2 should be highlighted
+      expect(formatted[1]).toContain('>');
+      // Check if it has color escape codes (or contains the yellow color function output)
+      expect(formatted[1]).toContain(pc.yellow('line2'));
+    });
+
+    it('should handle empty/null outputs gracefully', () => {
+      expect(formatOutputLines('')).toEqual([`   ${pc.gray('│')}   ${pc.dim('(empty)')}`]);
+      expect(formatOutputLines(null as any)).toEqual([`   ${pc.gray('│')}   ${pc.dim('(no output)')}`]);
+    });
+
+    it('should omit the > 1 prefix when there is only one line in the output', () => {
+      const output = 'singleLine';
+      const formatted = formatOutputLines(output, 1);
+      
+      expect(formatted).toHaveLength(1);
+      expect(formatted[0]).not.toContain('>');
+      expect(formatted[0]).not.toContain('1');
+      expect(formatted[0]).toContain(pc.yellow('singleLine'));
+    });
+
+    it('should truncate outputs if they exceed the max display size', () => {
+      const output = Array.from({ length: 50 }, (_, i) => `line ${i + 1}`).join('\n');
+      const formatted = formatOutputLines(output, 25);
+      
+      // Should contain truncation indicator
+      const hasTruncatedBefore = formatted.some(l => l.includes('truncated'));
+      expect(hasTruncatedBefore).toBe(true);
+    });
+  });
+
+  describe('formatErrorOutputLines', () => {
+    it('should format error lines with red color and gray borders', () => {
+      const errorOutput = 'error line 1\nerror line 2';
+      const formatted = formatErrorOutputLines(errorOutput);
+      
+      expect(formatted).toHaveLength(2);
+      expect(formatted[0]).toContain(pc.red('error line 1'));
+      expect(formatted[1]).toContain(pc.red('error line 2'));
+    });
+
+    it('should return empty array for empty inputs', () => {
+      expect(formatErrorOutputLines('')).toEqual([]);
+      expect(formatErrorOutputLines(null as any)).toEqual([]);
+    });
+  });
+});