@cifn/runner 0.0.1

package/src/steps/artifact-upload.ts

@@ -0,0 +1,89 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+export interface ArtifactUploadOptions {
+  name: string;
+  path: string;
+  workspace: string;
+  runId: string;
+  fileFnClient: {
+    upload(namespace: string, key: string, data: Buffer): Promise<string>;
+  };
+}
+
+export interface ArtifactUploadResult {
+  success: boolean;
+  fileId?: string;
+  lines: string[];
+  error?: string;
+}
+
+function collectFiles(dirPath: string): string[] {
+  const files: string[] = [];
+  if (!existsSync(dirPath)) return files;
+  const stat = statSync(dirPath);
+  if (stat.isFile()) return [dirPath];
+  if (!stat.isDirectory()) return files;
+  for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isFile()) {
+      files.push(fullPath);
+    } else if (entry.isDirectory()) {
+      files.push(...collectFiles(fullPath));
+    }
+  }
+  return files;
+}
+
+export async function executeArtifactUpload(options: ArtifactUploadOptions): Promise<ArtifactUploadResult> {
+  const { name, path: artifactPath, workspace, runId, fileFnClient } = options;
+  const lines: string[] = [];
+
+  // Validate artifact name length (max 256 chars)
+  if (name.length > 256) {
+    const msg = `Artifact name exceeds maximum length of 256 characters (actual: ${name.length})`;
+    lines.push(msg);
+    return { success: false, lines, error: msg };
+  }
+
+  const fullPath = join(workspace, artifactPath);
+
+  if (!existsSync(fullPath)) {
+    const msg = `Artifact path not found: ${artifactPath}`;
+    lines.push(msg);
+    return { success: false, lines, error: msg };
+  }
+
+  try {
+    lines.push(`Uploading artifact "${name}" from ${artifactPath}`);
+
+    const files = collectFiles(fullPath);
+    const buffers: Buffer[] = [];
+    const manifest: Array<{ relativePath: string; offset: number; size: number }> = [];
+
+    let offset = 0;
+    for (const file of files) {
+      const data = readFileSync(file);
+      const rel = relative(fullPath, file) || relative(workspace, file);
+      manifest.push({ relativePath: rel, offset, size: data.length });
+      buffers.push(data);
+      offset += data.length;
+    }
+
+    const manifestBuf = Buffer.from(JSON.stringify(manifest));
+    const headerBuf = Buffer.alloc(4);
+    headerBuf.writeUInt32BE(manifestBuf.length, 0);
+
+    const combined = Buffer.concat([headerBuf, manifestBuf, ...buffers]);
+
+    const namespace = `artifact:${runId}`;
+    const fileId = await fileFnClient.upload(namespace, name, combined);
+
+    lines.push(`Uploaded ${files.length} file(s), artifact fileId: ${fileId}`);
+    return { success: true, fileId, lines };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    lines.push(`Upload failed: ${msg}`);
+    return { success: false, lines, error: msg };
+  }
+}

package/src/steps/cache-restore.ts

@@ -0,0 +1,61 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+export interface CacheRestoreOptions {
+  key: string;
+  workspace: string;
+  fileFnClient: {
+    downloadByKey(namespace: string, key: string): Promise<Buffer | null>;
+  };
+}
+
+export interface CacheRestoreResult {
+  success: boolean;
+  hit: boolean;
+  lines: string[];
+  error?: string;
+}
+
+export async function executeCacheRestore(options: CacheRestoreOptions): Promise<CacheRestoreResult> {
+  const { key, workspace, fileFnClient } = options;
+  const lines: string[] = [];
+
+  // Validate cache key length (max 1KB)
+  const keyByteLength = Buffer.byteLength(key, 'utf8');
+  if (keyByteLength > 1024) {
+    const msg = `Cache key exceeds maximum length of 1KB (actual: ${keyByteLength} bytes)`;
+    lines.push(msg);
+    return { success: false, hit: false, lines, error: msg };
+  }
+
+  try {
+    lines.push(`Restoring cache with key "${key}"`);
+
+    const data = await fileFnClient.downloadByKey('cache', key);
+
+    if (!data) {
+      lines.push(`Cache miss for key "${key}"`);
+      return { success: true, hit: false, lines };
+    }
+
+    const manifestLen = data.readUInt32BE(0);
+    const manifestJson = data.subarray(4, 4 + manifestLen).toString('utf-8');
+    const manifest: Array<{ relativePath: string; offset: number; size: number }> = JSON.parse(manifestJson);
+
+    const dataStart = 4 + manifestLen;
+
+    for (const entry of manifest) {
+      const fileBuf = data.subarray(dataStart + entry.offset, dataStart + entry.offset + entry.size);
+      const outPath = join(workspace, entry.relativePath);
+      mkdirSync(dirname(outPath), { recursive: true });
+      writeFileSync(outPath, fileBuf);
+    }
+
+    lines.push(`Cache hit: restored ${manifest.length} file(s)`);
+    return { success: true, hit: true, lines };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    lines.push(`Cache restore failed: ${msg}`);
+    return { success: false, hit: false, lines, error: msg };
+  }
+}

package/src/steps/cache-save.ts

@@ -0,0 +1,88 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+export interface CacheSaveOptions {
+  key: string;
+  paths: string[];
+  workspace: string;
+  fileFnClient: {
+    upload(namespace: string, key: string, data: Buffer): Promise<string>;
+  };
+}
+
+export interface CacheSaveResult {
+  success: boolean;
+  lines: string[];
+  error?: string;
+}
+
+function collectFiles(dirPath: string, basePath: string): Array<{ relativePath: string; data: Buffer }> {
+  const results: Array<{ relativePath: string; data: Buffer }> = [];
+  if (!existsSync(dirPath)) return results;
+  const stat = statSync(dirPath);
+  if (stat.isFile()) {
+    results.push({ relativePath: relative(basePath, dirPath), data: readFileSync(dirPath) });
+    return results;
+  }
+  if (!stat.isDirectory()) return results;
+  for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isFile()) {
+      results.push({ relativePath: relative(basePath, fullPath), data: readFileSync(fullPath) });
+    } else if (entry.isDirectory()) {
+      results.push(...collectFiles(fullPath, basePath));
+    }
+  }
+  return results;
+}
+
+export async function executeCacheSave(options: CacheSaveOptions): Promise<CacheSaveResult> {
+  const { key, paths, workspace, fileFnClient } = options;
+  const lines: string[] = [];
+
+  // Validate cache key length (max 1KB)
+  const keyByteLength = Buffer.byteLength(key, 'utf8');
+  if (keyByteLength > 1024) {
+    const msg = `Cache key exceeds maximum length of 1KB (actual: ${keyByteLength} bytes)`;
+    lines.push(msg);
+    return { success: false, lines, error: msg };
+  }
+
+  try {
+    lines.push(`Saving cache with key "${key}"`);
+
+    const allFiles: Array<{ relativePath: string; data: Buffer }> = [];
+    for (const p of paths) {
+      const fullPath = join(workspace, p);
+      const files = collectFiles(fullPath, workspace);
+      allFiles.push(...files);
+    }
+
+    if (allFiles.length === 0) {
+      lines.push('No files found to cache');
+      return { success: true, lines };
+    }
+
+    const manifest: Array<{ relativePath: string; offset: number; size: number }> = [];
+    const buffers: Buffer[] = [];
+    let offset = 0;
+    for (const f of allFiles) {
+      manifest.push({ relativePath: f.relativePath, offset, size: f.data.length });
+      buffers.push(f.data);
+      offset += f.data.length;
+    }
+
+    const manifestBuf = Buffer.from(JSON.stringify(manifest));
+    const headerBuf = Buffer.alloc(4);
+    headerBuf.writeUInt32BE(manifestBuf.length, 0);
+    const combined = Buffer.concat([headerBuf, manifestBuf, ...buffers]);
+
+    await fileFnClient.upload('cache', key, combined);
+    lines.push(`Cached ${allFiles.length} file(s) under key "${key}"`);
+    return { success: true, lines };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    lines.push(`Cache save failed: ${msg}`);
+    return { success: false, lines, error: msg };
+  }
+}

package/src/steps/checkout.ts

@@ -0,0 +1,63 @@
+import { execSync } from 'node:child_process';
+
+export interface CheckoutOptions {
+  repo: string;
+  ref: string;
+  workspace: string;
+  token?: string;
+}
+
+export interface CheckoutResult {
+  success: boolean;
+  lines: string[];
+  error?: string;
+}
+
+export function executeCheckout(options: CheckoutOptions): CheckoutResult {
+  const { repo, ref, workspace, token } = options;
+  const lines: string[] = [];
+  const secretsToRedact: string[] = [];
+
+  let cloneUrl = repo;
+  if (token && cloneUrl.startsWith('https://')) {
+    const url = new URL(cloneUrl);
+    url.username = 'x-access-token';
+    url.password = token;
+    cloneUrl = url.toString();
+    secretsToRedact.push(token);
+    secretsToRedact.push(cloneUrl);
+  }
+
+  const redactLine = (line: string): string => {
+    let redacted = line;
+    for (const secret of secretsToRedact) {
+      if (secret.length > 0) {
+        redacted = redacted.split(secret).join('***');
+      }
+    }
+    return redacted;
+  };
+
+  try {
+    lines.push(`Cloning ${repo} at ref ${ref}`);
+
+    const cloneCmd = `git clone --depth 1 --branch ${ref} ${cloneUrl} .`;
+    const output = execSync(cloneCmd, {
+      cwd: workspace,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 120_000,
+    });
+    if (output) {
+      lines.push(...output.split('\n').filter(l => l !== '').map(redactLine));
+    }
+
+    lines.push(`Checkout complete: ${ref}`);
+    return { success: true, lines };
+  } catch (err: unknown) {
+    const error = err as { stderr?: string; message?: string };
+    const errMsg = typeof error.stderr === 'string' ? redactLine(error.stderr) : (error.message ? redactLine(error.message) : 'Unknown error');
+    lines.push(`Checkout failed: ${errMsg}`);
+    return { success: false, lines, error: errMsg };
+  }
+}

package/src/steps/hostfn-deploy.ts

@@ -0,0 +1,52 @@
+import { execSync } from 'node:child_process';
+
+export interface HostFnDeployOptions {
+  environment: string;
+  ci?: boolean;
+  local?: boolean;
+  workspace: string;
+  env?: Record<string, string>;
+}
+
+export interface HostFnDeployResult {
+  success: boolean;
+  exitCode: number;
+  lines: string[];
+  error?: string;
+}
+
+export function executeHostFnDeploy(options: HostFnDeployOptions): HostFnDeployResult {
+  const { environment, ci = true, local = false, workspace, env } = options;
+  const lines: string[] = [];
+
+  let command = `hostfn deploy ${environment}`;
+  if (local) command += ' --local';
+  if (ci) command += ' --ci';
+
+  lines.push(`Deploying: ${command}`);
+
+  try {
+    const output = execSync(command, {
+      cwd: workspace,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 600_000,
+      shell: '/bin/sh',
+      env: env ? { ...process.env, ...env } : process.env,
+    });
+    if (output) {
+      lines.push(...output.split('\n').filter(l => l !== ''));
+    }
+    lines.push('Deploy succeeded');
+    return { success: true, exitCode: 0, lines };
+  } catch (err: unknown) {
+    const error = err as { status?: number; stdout?: string; stderr?: string };
+    const stdout = typeof error.stdout === 'string' ? error.stdout : '';
+    const stderr = typeof error.stderr === 'string' ? error.stderr : '';
+    const exitCode = typeof error.status === 'number' ? error.status : 1;
+    if (stdout) lines.push(...stdout.split('\n').filter(l => l !== ''));
+    if (stderr) lines.push(...stderr.split('\n').filter(l => l !== ''));
+    lines.push(`Deploy failed with exit code ${exitCode}`);
+    return { success: false, exitCode, lines, error: `Deploy failed with exit code ${exitCode}` };
+  }
+}

package/src/steps/testfn-run.ts

@@ -0,0 +1,179 @@
+import { TestRunner, JsonReporter, type TestFnConfig } from '@testfn/core';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+export interface TestFnRunOptions {
+  framework?: string;
+  testPattern?: string;
+  reporter?: string;
+  outputPath?: string;
+  workspace: string;
+  env?: Record<string, string>;
+  parallel?: number | 'auto';
+  timeout?: number;
+  retries?: number;
+}
+
+export interface TestFnRunResult {
+  success: boolean;
+  exitCode: number;
+  lines: string[];
+  error?: string;
+}
+
+export function executeTestFnRun(options: TestFnRunOptions): TestFnRunResult {
+  const {
+    framework = 'vitest',
+    testPattern,
+    reporter,
+    outputPath = './testfn-results.json',
+    workspace,
+    env,
+    parallel,
+    timeout,
+    retries
+  } = options;
+  const lines: string[] = [];
+
+  lines.push(`Running tests with testfn SDK (framework: ${framework})`);
+
+  try {
+    if (!['vitest', 'playwright', 'jest'].includes(framework)) {
+      throw new Error(`Unsupported framework: ${framework}. Supported: vitest, playwright, jest`);
+    }
+
+    const config: TestFnConfig = {
+      framework: framework as 'vitest' | 'playwright' | 'jest',
+      testPattern: testPattern || './tests/**/*.{test,spec}.{ts,js}',
+      parallel,
+      timeout,
+      retries,
+      env,
+      reporters: reporter === 'json' ? [new JsonReporter(join(workspace, outputPath))] : undefined,
+    };
+
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(workspace);
+      
+      const runner = new TestRunner(config);
+      const results = runner.run();
+      
+      process.chdir(originalCwd);
+
+      if (results && typeof results === 'object' && 'then' in results) {
+        throw new Error('executeTestFnRun must be called from async context or use sync adapter');
+      }
+
+      lines.push(`Tests completed: ${(results as any).summary?.total || 0} total`);
+      lines.push(`Passed: ${(results as any).summary?.passed || 0}, Failed: ${(results as any).summary?.failed || 0}`);
+      
+      if (reporter === 'json' && outputPath) {
+        const fullPath = join(workspace, outputPath);
+        if (existsSync(fullPath)) {
+          lines.push(`JSON report written to ${outputPath}`);
+        }
+      }
+
+      const hasFailed = (results as any).summary?.failed > 0;
+      if (hasFailed) {
+        return {
+          success: false,
+          exitCode: 1,
+          lines,
+          error: 'Tests failed'
+        };
+      }
+
+      return { success: true, exitCode: 0, lines };
+    } catch (innerErr) {
+      process.chdir(originalCwd);
+      throw innerErr;
+    }
+  } catch (err: unknown) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    lines.push(`Test execution failed: ${errorMessage}`);
+    return {
+      success: false,
+      exitCode: 1,
+      lines,
+      error: errorMessage
+    };
+  }
+}
+
+export async function executeTestFnRunAsync(options: TestFnRunOptions): Promise<TestFnRunResult> {
+  const {
+    framework = 'vitest',
+    testPattern,
+    reporter,
+    outputPath = './testfn-results.json',
+    workspace,
+    env,
+    parallel,
+    timeout,
+    retries
+  } = options;
+  const lines: string[] = [];
+
+  lines.push(`Running tests with testfn SDK (framework: ${framework})`);
+
+  try {
+    if (!['vitest', 'playwright', 'jest'].includes(framework)) {
+      throw new Error(`Unsupported framework: ${framework}. Supported: vitest, playwright, jest`);
+    }
+
+    const config: TestFnConfig = {
+      framework: framework as 'vitest' | 'playwright' | 'jest',
+      testPattern: testPattern || './tests/**/*.{test,spec}.{ts,js}',
+      parallel,
+      timeout,
+      retries,
+      env,
+      reporters: reporter === 'json' ? [new JsonReporter(join(workspace, outputPath))] : undefined,
+    };
+
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(workspace);
+      
+      const runner = new TestRunner(config);
+      const results = await runner.run();
+      
+      process.chdir(originalCwd);
+
+      lines.push(`Tests completed: ${results.summary.total} total`);
+      lines.push(`Passed: ${results.summary.passed}, Failed: ${results.summary.failed}`);
+      
+      if (reporter === 'json' && outputPath) {
+        const fullPath = join(workspace, outputPath);
+        if (existsSync(fullPath)) {
+          lines.push(`JSON report written to ${outputPath}`);
+        }
+      }
+
+      if (results.summary.failed > 0) {
+        return {
+          success: false,
+          exitCode: 1,
+          lines,
+          error: 'Tests failed'
+        };
+      }
+
+      return { success: true, exitCode: 0, lines };
+    } catch (innerErr) {
+      process.chdir(originalCwd);
+      throw innerErr;
+    }
+  } catch (err: unknown) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    lines.push(`Test execution failed: ${errorMessage}`);
+    return {
+      success: false,
+      exitCode: 1,
+      lines,
+      error: errorMessage
+    };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts', 'src/server.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+});

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+  },
+});