@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/sdk-XK6HQU7S.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { findWorkspaceRoot, detectEnvironment } from './chunk-JMJP4A47.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { Command } from 'commander';
+import { spawnSync, execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+import { createCLILogger, CLIError } from '@runa-ai/runa';
+import chalk from 'chalk';
+
+createRequire(import.meta.url);
+
+// src/commands/sdk/index.ts
+init_esm_shims();
+
+// src/commands/sdk/commands/publish.ts
+init_esm_shims();
+var PUBLISHABLE_PACKAGES = [
+  { name: "SDK", dir: "sdk", publishName: "@runa-ai/runa" },
+  { name: "CLI", dir: "cli", publishName: "@runa-ai/runa-cli" },
+  {
+    name: "xstate-test-plugin",
+    dir: "runa-xstate-test-plugin",
+    publishName: "@runa-ai/runa-xstate-test-plugin"
+  }
+];
+function assertRunaRepo() {
+  const env = detectEnvironment();
+  if (env !== "runa-repo") {
+    throw new CLIError("This command is only available in runa-repo", "RUNA_REPO_ONLY", [
+      "This command can only be run from the runa monorepo",
+      "pj-repos should use GitHub Actions workflow for publishing",
+      `Detected environment: ${env}`
+    ]);
+  }
+}
+function getCurrentBranch() {
+  try {
+    return execSync("git rev-parse --abbrev-ref HEAD", { stdio: "pipe" }).toString().trim();
+  } catch {
+    return "unknown";
+  }
+}
+function assertMainBranch(options) {
+  if (options.check) return;
+  if (options.force) return;
+  const branch = getCurrentBranch();
+  if (branch !== "main") {
+    throw new CLIError("Publishing is only allowed from main branch", "NOT_MAIN_BRANCH", [
+      `Current branch: ${branch}`,
+      "Switch to main: git checkout main && git pull",
+      "Or use --force to publish from current branch (use with caution)"
+    ]);
+  }
+}
+function assertNodeAuthToken(options) {
+  if (options.check || options.dryRun) return;
+  if (!process.env.NODE_AUTH_TOKEN) {
+    throw new CLIError("NODE_AUTH_TOKEN is required for publishing", "AUTH_TOKEN_MISSING", [
+      "Set the token: export NODE_AUTH_TOKEN=$(gh auth token)",
+      "Or use --dry-run to preview without publishing",
+      "Or use --check to only check versions"
+    ]);
+  }
+}
+function getPackageVersion(packagePath) {
+  const packageJsonPath = path.join(packagePath, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    throw new CLIError(`package.json not found at ${packagePath}`, "PACKAGE_NOT_FOUND");
+  }
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  return packageJson.version;
+}
+function checkVersionExists(publishName, version) {
+  try {
+    execSync(`pnpm view "${publishName}@${version}" version`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveWorkspaceDependencies(workspaceRoot, packages, logger) {
+  const sdkPackage = packages.find((p) => p.name === "SDK");
+  const xstatePluginPackage = packages.find((p) => p.name === "xstate-test-plugin");
+  if (!sdkPackage) return;
+  const cliPackagePath = path.join(workspaceRoot, "packages", "cli", "package.json");
+  if (!existsSync(cliPackagePath)) return;
+  let content = readFileSync(cliPackagePath, "utf-8");
+  let updated = false;
+  if (content.includes('"@runa-ai/runa": "workspace:*"')) {
+    logger.info(chalk.dim(`  Resolving @runa-ai/runa workspace:* \u2192 ^${sdkPackage.version}`));
+    content = content.replace(
+      '"@runa-ai/runa": "workspace:*"',
+      `"@runa-ai/runa": "^${sdkPackage.version}"`
+    );
+    updated = true;
+  }
+  if (xstatePluginPackage && content.includes('"@runa-ai/runa-xstate-test-plugin": "workspace:*"')) {
+    logger.info(
+      chalk.dim(
+        `  Resolving @runa-ai/runa-xstate-test-plugin workspace:* \u2192 ^${xstatePluginPackage.version}`
+      )
+    );
+    content = content.replace(
+      '"@runa-ai/runa-xstate-test-plugin": "workspace:*"',
+      `"@runa-ai/runa-xstate-test-plugin": "^${xstatePluginPackage.version}"`
+    );
+    updated = true;
+  }
+  if (updated) {
+    writeFileSync(cliPackagePath, content, "utf-8");
+  }
+}
+function restoreWorkspaceDependencies(workspaceRoot) {
+  const cliPackagePath = path.join(workspaceRoot, "packages", "cli", "package.json");
+  if (!existsSync(cliPackagePath)) return;
+  let content = readFileSync(cliPackagePath, "utf-8");
+  content = content.replace(/"@runa-ai\/runa": "\^[\d.]+"/, '"@runa-ai/runa": "workspace:*"');
+  content = content.replace(
+    /"@runa-ai\/runa-xstate-test-plugin": "\^[\d.]+"/,
+    '"@runa-ai/runa-xstate-test-plugin": "workspace:*"'
+  );
+  writeFileSync(cliPackagePath, content, "utf-8");
+}
+function runQualityChecks(workspaceRoot, logger) {
+  logger.step("Running quality checks", 1);
+  logger.info("  Running type-check...");
+  const typeCheck = spawnSync("pnpm", ["type-check"], {
+    cwd: workspaceRoot,
+    stdio: "inherit",
+    shell: true
+  });
+  if (typeCheck.status !== 0) {
+    throw new CLIError("Type check failed", "TYPE_CHECK_FAILED", [
+      "Fix TypeScript errors before publishing",
+      "Run: pnpm type-check"
+    ]);
+  }
+  logger.info(chalk.green("  \u2713 Type check passed"));
+  logger.info("  Running lint...");
+  const lint = spawnSync("pnpm", ["lint"], {
+    cwd: workspaceRoot,
+    stdio: "inherit",
+    shell: true
+  });
+  if (lint.status !== 0) {
+    throw new CLIError("Lint check failed", "LINT_FAILED", [
+      "Fix lint errors before publishing",
+      "Run: pnpm lint --write"
+    ]);
+  }
+  logger.info(chalk.green("  \u2713 Lint passed"));
+}
+function buildAllPackages(workspaceRoot, logger) {
+  logger.step("Building all packages", 2);
+  for (const pkgConfig of PUBLISHABLE_PACKAGES) {
+    logger.info(`  Building ${pkgConfig.name}...`);
+    const result = spawnSync("pnpm", ["--filter", pkgConfig.publishName, "build"], {
+      cwd: workspaceRoot,
+      stdio: "inherit",
+      // Show build output for debugging
+      shell: true
+    });
+    if (result.status !== 0) {
+      throw new CLIError(`Failed to build ${pkgConfig.name}`, "BUILD_FAILED", [
+        "Check build output above for errors",
+        `Run: pnpm --filter "${pkgConfig.publishName}" build`
+      ]);
+    }
+    logger.info(chalk.green(`  \u2713 ${pkgConfig.name} built`));
+  }
+}
+function publishPackage(pkg, dryRun, logger) {
+  const result = spawnSync(
+    "pnpm",
+    ["publish", "--no-git-checks", ...dryRun ? ["--dry-run"] : []],
+    {
+      cwd: pkg.path,
+      stdio: "pipe",
+      shell: true
+    }
+  );
+  if (result.status !== 0) {
+    const stderr = result.stderr?.toString() || "";
+    if (stderr.includes("already exists")) {
+      logger.info(chalk.yellow(`  \u23ED\uFE0F  ${pkg.name}@${pkg.version} already exists (skipped)`));
+      return;
+    }
+    throw new CLIError(`Failed to publish ${pkg.name}`, "PUBLISH_FAILED", [
+      "Check NODE_AUTH_TOKEN is set correctly",
+      "Ensure you have write access to GitHub Packages",
+      stderr ? `Error: ${stderr}` : ""
+    ]);
+  }
+}
+function verifyInstallation(packages, logger) {
+  logger.step("Verifying installation", 4);
+  for (const pkg of packages) {
+    logger.info(`  Checking ${pkg.publishName}@${pkg.version}...`);
+    const maxRetries = 3;
+    let verified = false;
+    for (let i = 0; i < maxRetries; i++) {
+      if (checkVersionExists(pkg.publishName, pkg.version)) {
+        verified = true;
+        break;
+      }
+      if (i < maxRetries - 1) {
+        logger.info(
+          chalk.dim(`    Waiting for registry propagation... (attempt ${i + 2}/${maxRetries})`)
+        );
+        execSync("sleep 2");
+      }
+    }
+    if (verified) {
+      logger.info(chalk.green(`  \u2713 ${pkg.publishName}@${pkg.version} available`));
+    } else {
+      logger.warn(
+        `  \u26A0\uFE0F  ${pkg.publishName}@${pkg.version} not yet available (may take a few minutes)`
+      );
+    }
+  }
+}
+function collectPackageInfo(workspaceRoot, logger, stepNum) {
+  logger.step("Collecting package info", stepNum);
+  const packages = [];
+  for (const pkgConfig of PUBLISHABLE_PACKAGES) {
+    const pkgPath = path.join(workspaceRoot, "packages", pkgConfig.dir);
+    const version = getPackageVersion(pkgPath);
+    const exists = checkVersionExists(pkgConfig.publishName, version);
+    packages.push({
+      name: pkgConfig.name,
+      path: pkgPath,
+      version,
+      publishName: pkgConfig.publishName,
+      exists
+    });
+    const statusIcon = exists ? chalk.yellow("\u23ED\uFE0F") : chalk.green("\u{1F4E6}");
+    const statusText = exists ? "exists" : "new";
+    logger.info(`  ${statusIcon} ${pkgConfig.publishName}@${version} (${statusText})`);
+  }
+  logger.info("");
+  return packages;
+}
+function publishPackages(toPublish, dryRun, logger, stepNum) {
+  logger.step("Publishing packages", stepNum);
+  for (const pkg of toPublish) {
+    const action = dryRun ? "Would publish" : "Publishing";
+    logger.info(`  ${action} ${pkg.publishName}@${pkg.version}...`);
+    publishPackage(pkg, dryRun, logger);
+    if (!dryRun) {
+      logger.info(chalk.green(`  \u2713 ${pkg.name} published`));
+    }
+  }
+  logger.info("");
+  logger.success(
+    dryRun ? `Dry run complete - ${toPublish.length} package(s) would be published` : `${toPublish.length} package(s) published successfully`
+  );
+}
+function handleCheckOnlyMode(packages, isCheckMode, logger) {
+  if (!isCheckMode) return false;
+  const newPackages = packages.filter((p) => !p.exists);
+  if (newPackages.length === 0) {
+    logger.success("All versions already published");
+  } else {
+    logger.info(`${newPackages.length} package(s) ready to publish`);
+  }
+  return true;
+}
+function buildIfNeeded(workspaceRoot, skipBuild, logger) {
+  if (!skipBuild) {
+    buildAllPackages(workspaceRoot, logger);
+    logger.info("");
+  } else {
+    logger.info(chalk.dim("  Skipping build (--skip-build)"));
+    logger.info("");
+  }
+}
+function printPublishSummary(logger) {
+  logger.info("");
+  logger.info(chalk.dim("Registry: https://npm.pkg.github.com"));
+  logger.info(chalk.dim("Verify: pnpm view @runa-ai/runa versions"));
+}
+async function runPublishWorkflow(options, logger) {
+  assertRunaRepo();
+  assertMainBranch(options);
+  assertNodeAuthToken(options);
+  const workspaceRoot = findWorkspaceRoot();
+  if (!workspaceRoot) {
+    throw new CLIError("Could not find workspace root", "WORKSPACE_NOT_FOUND");
+  }
+  logger.section("SDK Publish");
+  if (options.dryRun) {
+    logger.info(chalk.yellow("DRY RUN MODE - No actual publishing will occur\n"));
+  }
+  if (options.quality && !options.check) {
+    runQualityChecks(workspaceRoot, logger);
+    logger.info("");
+  }
+  const stepNum = options.quality ? 2 : 1;
+  const packages = collectPackageInfo(workspaceRoot, logger, stepNum);
+  if (handleCheckOnlyMode(packages, options.check === true, logger)) {
+    return;
+  }
+  const toPublish = packages.filter((p) => !p.exists);
+  if (toPublish.length === 0) {
+    logger.success("All versions already published - nothing to do");
+    return;
+  }
+  buildIfNeeded(workspaceRoot, options.skipBuild === true, logger);
+  logger.step("Resolving dependencies", options.skipBuild ? 2 : 3);
+  resolveWorkspaceDependencies(workspaceRoot, packages, logger);
+  logger.info("");
+  try {
+    publishPackages(toPublish, options.dryRun === true, logger, options.skipBuild ? 3 : 4);
+    if (options.verify && !options.dryRun) {
+      logger.info("");
+      verifyInstallation(toPublish, logger);
+    }
+  } finally {
+    restoreWorkspaceDependencies(workspaceRoot);
+  }
+  printPublishSummary(logger);
+}
+var publishCommand = new Command("publish").description("Publish SDK packages to GitHub Packages").option("--dry-run", "Show what would be published without publishing").option("--check", "Only check versions (no build, no publish)").option("--skip-build", "Skip build step (use existing dist/)").option("--quality", "Run type-check + lint before build (like CI)").option("--verify", "Verify installation after publish").option("--force", "Allow publish from non-main branch (use with caution)").action(async (options) => {
+  const logger = createCLILogger("sdk:publish");
+  try {
+    await runPublishWorkflow(options, logger);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "SDK publish failed",
+      "PUBLISH_ERROR",
+      ["Check error details above", "Ensure NODE_AUTH_TOKEN is set"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+// src/commands/sdk/index.ts
+var sdkCommand = new Command("sdk").description(
+  "SDK development and publishing (runa-repo only)"
+);
+sdkCommand.addCommand(publishCommand);
+
+export { sdkCommand };

package/dist/services-7VK5KZTO.js

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { spawnSync, execSync } from 'child_process';
+import { basename } from 'path';
+import { Command } from 'commander';
+
+createRequire(import.meta.url);
+
+// src/commands/services/index.ts
+init_esm_shims();
+var SERVICE_MAP = {
+  postgrest: "rest",
+  rest: "rest",
+  studio: "studio",
+  realtime: "realtime",
+  storage: "storage",
+  auth: "auth",
+  "edge-runtime": "edge_runtime",
+  inbucket: "inbucket",
+  "pg-meta": "pg_meta",
+  kong: "kong"
+};
+var SCHEMA_DEPENDENT_SERVICES = ["postgrest", "rest"];
+function getProjectName() {
+  try {
+    const result = spawnSync("supabase", ["status", "--output", "json"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.stdout) {
+      const status = JSON.parse(result.stdout);
+      if (status.DB?.Status === "running") {
+        const containers = execSync('docker ps --format "{{.Names}}"', { encoding: "utf-8" });
+        const match = containers.match(/supabase_db_(\w+)/);
+        if (match) {
+          return match[1];
+        }
+      }
+    }
+  } catch {
+  }
+  return basename(process.cwd());
+}
+function getContainerName(service) {
+  const suffix = SERVICE_MAP[service.toLowerCase()] || service;
+  const project = getProjectName();
+  return `supabase_${suffix}_${project}`;
+}
+function getContainerStatus(containerName) {
+  const result = spawnSync("docker", ["inspect", "--format", "{{.State.Status}}", containerName], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    return "not_found";
+  }
+  return result.stdout?.trim() === "running" ? "running" : "stopped";
+}
+function startContainer(containerName, service) {
+  const startResult = spawnSync("docker", ["start", containerName], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (startResult.status === 0) {
+    return true;
+  }
+  console.error(`\u274C Failed to start ${service}: ${startResult.stderr}`);
+  return false;
+}
+function getContainerHealthStatus(containerName) {
+  const healthResult = spawnSync(
+    "docker",
+    ["inspect", "--format", "{{.State.Health.Status}}", containerName],
+    { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+  );
+  return healthResult.stdout?.trim() || "";
+}
+async function waitForServiceHealth(service, containerName, timeoutSeconds) {
+  console.log(`   \u2192 Waiting for ${service} to be healthy (timeout: ${timeoutSeconds}s)...`);
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutSeconds * 1e3) {
+    const healthStatus = getContainerHealthStatus(containerName);
+    if (healthStatus === "healthy") {
+      console.log(`\u2705 ${service} started and healthy`);
+      return;
+    }
+    if (!healthStatus) {
+      const runStatus = getContainerStatus(containerName);
+      if (runStatus === "running") {
+        console.log(`\u2705 ${service} started (no health check)`);
+        return;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  }
+  console.warn(`\u26A0\uFE0F ${service} started but health check timed out`);
+}
+async function startService(service, options) {
+  const containerName = getContainerName(service);
+  const status = getContainerStatus(containerName);
+  if (status === "not_found") {
+    console.error(`\u274C Container ${containerName} not found`);
+    console.log('   \u2192 Run "supabase start" first to create containers');
+    return false;
+  }
+  if (status === "running") {
+    console.log(`\u2705 ${service} is already running`);
+    return true;
+  }
+  console.log(`\u2192 Starting ${service}...`);
+  if (!startContainer(containerName, service)) {
+    return false;
+  }
+  if (options.wait === false) {
+    console.log(`\u2705 ${service} started`);
+    return true;
+  }
+  const timeout = options.timeout || 30;
+  await waitForServiceHealth(service, containerName, timeout);
+  return true;
+}
+function listServices() {
+  const project = getProjectName();
+  console.log(`
+Supabase Services (project: ${project}):
+`);
+  const uniqueServices = [
+    "postgrest",
+    "studio",
+    "realtime",
+    "storage",
+    "auth",
+    "edge-runtime",
+    "inbucket",
+    "pg-meta",
+    "kong"
+  ];
+  for (const service of uniqueServices) {
+    const containerName = getContainerName(service);
+    const status = getContainerStatus(containerName);
+    const statusIcon = status === "running" ? "\u{1F7E2}" : status === "stopped" ? "\u{1F534}" : "\u26AA";
+    const schemaNote = SCHEMA_DEPENDENT_SERVICES.includes(service) ? " (schema-dependent)" : "";
+    console.log(`  ${statusIcon} ${service.padEnd(15)} ${status}${schemaNote}`);
+  }
+  console.log("\nSchema-dependent services should be started after schema apply.");
+  console.log("Use: runa services start <service>\n");
+}
+var servicesCommand = new Command("services").description("Manage Supabase services (start/stop individual services)").addCommand(
+  new Command("start").description("Start a specific Supabase service").argument("<service>", "Service name (postgrest, studio, realtime, etc.)").option("--no-wait", "Do not wait for health check").option("--timeout <seconds>", "Health check timeout in seconds", "30").action(async (service, options) => {
+    const success = await startService(service, {
+      wait: options.wait,
+      timeout: Number.parseInt(options.timeout, 10)
+    });
+    process.exit(success ? 0 : 1);
+  })
+).addCommand(
+  new Command("list").description("List all Supabase services and their status").action(() => {
+    listServices();
+  })
+).addCommand(
+  new Command("start-schema-dependent").description("Start all schema-dependent services (postgrest, etc.)").option("--timeout <seconds>", "Health check timeout per service", "30").action(async (options) => {
+    console.log("Starting schema-dependent services...\n");
+    let allSuccess = true;
+    for (const service of SCHEMA_DEPENDENT_SERVICES) {
+      const success = await startService(service, {
+        timeout: Number.parseInt(options.timeout, 10)
+      });
+      if (!success) {
+        allSuccess = false;
+      }
+    }
+    process.exit(allSuccess ? 0 : 1);
+  })
+);
+
+export { servicesCommand };

package/dist/session-SFW5QSXZ.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { createCLILogger } from '@runa-ai/runa/cli-runtime';
+import { listSessions, formatDuration, cleanupStaleSessions, removeSession, isSessionCheckDisabled, getCurrentSessionId, checkActiveSessions, createSession, addActivity, checkConflicts, formatConflictDetails } from '@runa-ai/runa/session';
+import { Command } from 'commander';
+
+createRequire(import.meta.url);
+
+// src/commands/session/index.ts
+init_esm_shims();
+var logger = createCLILogger("session");
+async function listSessionsAction() {
+  const sessions = await listSessions();
+  if (sessions.length === 0) {
+    logger.info("No active sessions");
+    return;
+  }
+  const now = Date.now();
+  logger.info(`Active sessions: ${sessions.length}`);
+  console.log("");
+  for (const session of sessions) {
+    const lastHeartbeat = new Date(session.lastHeartbeat).getTime();
+    const age = formatDuration(now - lastHeartbeat);
+    const isCurrent = session.pid === process.pid;
+    console.log(`  ${isCurrent ? "\u2192" : " "} Session: ${session.sessionId.slice(0, 8)}`);
+    console.log(`    PID: ${session.pid}`);
+    console.log(`    Last active: ${age}`);
+    console.log(`    CWD: ${session.cwd}`);
+    if (session.activity.length > 0) {
+      console.log("    Recent activities:");
+      for (const activity of session.activity.slice(0, 3)) {
+        const target = activity.target ? ` (${activity.target})` : "";
+        console.log(`      - ${activity.type}${target}`);
+      }
+    }
+    console.log("");
+  }
+}
+async function cleanupAction() {
+  const cleaned = await cleanupStaleSessions();
+  if (cleaned === 0) {
+    logger.info("No stale sessions to clean up");
+  } else {
+    logger.success(`Cleaned up ${cleaned} stale session(s)`);
+  }
+}
+async function clearAction() {
+  const sessions = await listSessions();
+  for (const session of sessions) {
+    await removeSession(session.sessionId);
+  }
+  logger.success(`Cleared ${sessions.length} session(s)`);
+}
+async function checkAction() {
+  if (isSessionCheckDisabled()) {
+    return;
+  }
+  const sessionId = getCurrentSessionId();
+  const result = await checkActiveSessions(sessionId);
+  if (!result.hasConflict) {
+    return;
+  }
+  console.log("");
+  console.log("\u26A0\uFE0F  Multi-Session Advisory");
+  console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  console.log("");
+  console.log(`\u{1F504} ${result.message}`);
+  for (const session of result.conflictingSessions.slice(0, 2)) {
+    console.log(`   Session ${session.sessionId.slice(0, 8)} (PID ${session.pid})`);
+    if (session.activities.length > 0) {
+      const activity = session.activities[0];
+      const target = activity.target ? `: ${activity.target}` : "";
+      console.log(`   \u2514\u2500 Last activity: ${activity.type}${target}`);
+    }
+  }
+  console.log("");
+  console.log("\u{1F4A1} Proceeding anyway. To suppress:");
+  console.log("   RUNA_SKIP_SESSION_CHECK=1");
+  console.log("");
+  console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  console.log("");
+}
+async function registerAction(activityType, options) {
+  if (isSessionCheckDisabled()) {
+    return;
+  }
+  const validTypes = ["build", "edit", "install", "test", "db-sync"];
+  if (!validTypes.includes(activityType)) {
+    return;
+  }
+  const sessionId = getCurrentSessionId();
+  const sessions = await listSessions();
+  const existing = sessions.find(
+    (s) => s.sessionId === sessionId || s.pid === process.pid
+  );
+  if (!existing) {
+    await createSession();
+  }
+  await addActivity(sessionId, activityType, options.target);
+  const result = await checkConflicts(sessionId, activityType, options.target);
+  if (result.hasConflict) {
+    console.log("");
+    console.log(`\u26A0\uFE0F  ${result.message}`);
+    console.log(formatConflictDetails(result));
+    console.log("");
+  }
+}
+async function startAction() {
+  const session = await createSession();
+  logger.success(`Session started: ${session.sessionId.slice(0, 8)}`);
+  console.log(`  PID: ${session.pid}`);
+  console.log(`  Use 'runa session:stop' to end session`);
+}
+async function stopAction() {
+  const sessions = await listSessions();
+  const current = sessions.find((s) => s.pid === process.pid);
+  if (current) {
+    await removeSession(current.sessionId);
+    logger.success("Session stopped");
+  } else {
+    logger.info("No active session for this process");
+  }
+}
+var sessionListCommand = new Command("session:list").description("List active sessions").action(listSessionsAction);
+var sessionCleanupCommand = new Command("session:cleanup").description("Remove stale sessions (> 2 minutes old)").action(cleanupAction);
+var sessionClearCommand = new Command("session:clear").description("Remove all sessions (for debugging)").action(clearAction);
+var sessionCheckCommand = new Command("session:check").description("Check for active sessions (used by hooks)").action(checkAction);
+var sessionRegisterCommand = new Command("session:register").description("Register activity (used by hooks)").argument("<type>", "Activity type: build, edit, install, test, db-sync").option("--target <path>", "Target file or package").action(registerAction);
+var sessionStartCommand = new Command("session:start").description("Start a new session").action(startAction);
+var sessionStopCommand = new Command("session:stop").description("Stop current session").action(stopAction);
+var sessionCommands = [
+  sessionListCommand,
+  sessionCleanupCommand,
+  sessionClearCommand,
+  sessionCheckCommand,
+  sessionRegisterCommand,
+  sessionStartCommand,
+  sessionStopCommand
+];
+
+export { sessionCheckCommand, sessionCleanupCommand, sessionClearCommand, sessionCommands, sessionListCommand, sessionRegisterCommand, sessionStartCommand, sessionStopCommand };

package/dist/signal-handler-DO3OANW5.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+export { isShuttingDown, registerCleanup, setupSignalHandlers, unregisterCleanup } from './chunk-TYIAD6SB.js';
+import './chunk-VRXHCR5K.js';
+
+createRequire(import.meta.url);