conductor-oss 0.2.20 → 0.3.1

package/web/.next/standalone/packages/web/src/app/api/workspaces/route.ts

@@ -1,592 +1,6 @@
-import { type NextRequest, NextResponse } from "next/server";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, resolve } from "node:path";
-import { homedir } from "node:os";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { parse, stringify } from "yaml";
-import {
-  buildConductorBoard,
-  buildProjectConfigRecord,
-  generateSessionPrefix,
-  normalizeProjectConfigMap,
-  syncWorkspaceSupportFiles,
-} from "@conductor-oss/core";
-import { getServices, invalidateServicesCache } from "@/lib/services";
-import { guardApiAccess, guardApiActionAccess } from "@/lib/auth";
-import { normalizeRootProjectPaths, syncProjectLocalConfig } from "@/lib/projectConfigSync";
-import { getResolvedDefaultAgentModel, getResolvedDefaultAgentReasoningEffort } from "@/lib/runtimeAgentModels";
-
-const execFileAsync = promisify(execFile);
-
-type WorkspaceCreateMode = "git" | "local";
-
-type WorkspaceRequestBody = {
-  mode?: unknown;
-  projectId?: unknown;
-  agent?: unknown;
-  defaultBranch?: unknown;
-  useWorktree?: unknown;
-  gitUrl?: unknown;
-  path?: unknown;
-  initializeGit?: unknown;
-};
-
-type MutableConfig = Record<string, unknown>;
-
-function asNonEmptyString(value: unknown): string | null {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-
-function expandHome(value: string): string {
-  if (value.startsWith("~/")) {
-    return resolve(homedir(), value.slice(2));
-  }
-  return resolve(value);
-}
-
-function slugifyProjectId(input: string): string {
-  const slug = input
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 64);
-  return slug || "workspace";
-}
-
-function ensureUniqueProjectId(baseId: string, existingIds: Set<string>): string {
-  if (!existingIds.has(baseId)) return baseId;
-  let suffix = 2;
-  while (existingIds.has(`${baseId}-${suffix}`)) {
-    suffix += 1;
-  }
-  return `${baseId}-${suffix}`;
-}
-
-function extractRepoNameFromGitUrl(gitUrl: string): string | null {
-  const sshMatch = gitUrl.match(/^git@[^:]+:(.+)$/);
-  const candidate = sshMatch ? sshMatch[1] : gitUrl;
-
-  try {
-    const url = new URL(candidate);
-    const segments = url.pathname
-      .replace(/^\/+/, "")
-      .replace(/\.git$/i, "")
-      .split("/")
-      .filter(Boolean);
-    if (segments.length >= 2) {
-      return `${segments[segments.length - 2]}/${segments[segments.length - 1]}`;
-    }
-    if (segments.length === 1) {
-      return segments[0];
-    }
-    return null;
-  } catch {
-    const normalized = candidate.replace(/\.git$/i, "");
-    const segments = normalized.split("/").filter(Boolean);
-    if (segments.length >= 2) {
-      return `${segments[segments.length - 2]}/${segments[segments.length - 1]}`;
-    }
-    return segments[segments.length - 1] ?? null;
-  }
-}
-
-function deriveProjectIdFromInputs(params: {
-  providedId: string | null;
-  gitUrl: string | null;
-  path: string | null;
-}): string {
-  if (params.providedId) return slugifyProjectId(params.providedId);
-
-  const fromRepo = params.gitUrl
-    ? extractRepoNameFromGitUrl(params.gitUrl)?.split("/").pop() ?? null
-    : null;
-  if (fromRepo) return slugifyProjectId(fromRepo);
-
-  const fromPath = params.path ? basename(params.path) : null;
-  if (fromPath) return slugifyProjectId(fromPath);
-
-  return "workspace";
-}
-
-function inferBaseProjectsDir(existingPaths: string[]): string {
-  const counts = new Map<string, number>();
-
-  for (const rawPath of existingPaths) {
-    const resolvedPath = expandHome(rawPath);
-    const isLikelyFile = /\.[a-z0-9]+$/i.test(basename(resolvedPath));
-    const dir = isLikelyFile ? dirname(resolvedPath) : dirname(resolvedPath) === resolvedPath ? resolvedPath : dirname(resolvedPath);
-    counts.set(dir, (counts.get(dir) ?? 0) + 1);
-  }
-
-  const best = [...counts.entries()].sort((left, right) => right[1] - left[1])[0]?.[0];
-  return best ?? resolve(homedir(), ".openclaw", "workspace", "projects");
-}
-
-async function runGit(cwd: string, args: string[]): Promise<string> {
-  const result = await execFileAsync("git", args, {
-    cwd,
-    timeout: 90_000,
-  });
-  return result.stdout.trim();
-}
-
-async function isGitRepository(path: string): Promise<boolean> {
-  try {
-    await runGit(path, ["rev-parse", "--is-inside-work-tree"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function detectDefaultBranch(path: string, fallback: string): Promise<string> {
-  try {
-    const remoteHead = await runGit(path, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
-    if (remoteHead.startsWith("origin/")) {
-      return remoteHead.slice("origin/".length);
-    }
-  } catch {
-    // Ignore remote-less repos.
-  }
-
-  try {
-    const head = await runGit(path, ["symbolic-ref", "--short", "HEAD"]);
-    if (head.length > 0 && head !== "HEAD") return head;
-  } catch {
-    // Detached or empty repository.
-  }
-
-  return fallback;
-}
-
-async function ensureInitialCommit(path: string): Promise<void> {
-  let hasCommit = true;
-  try {
-    await runGit(path, ["rev-parse", "--verify", "HEAD"]);
-  } catch {
-    hasCommit = false;
-  }
-
-  if (hasCommit) return;
-
-  await runGit(path, ["add", "-A"]);
-  await runGit(path, ["-c", "user.name=Conductor", "-c", "user.email=conductor@local", "commit", "--allow-empty", "-m", "chore: initialize workspace"]);
-}
-
-async function initializeGitRepository(path: string, branch: string): Promise<void> {
-  try {
-    await runGit(path, ["init", "-b", branch]);
-  } catch {
-    await runGit(path, ["init"]);
-    try {
-      await runGit(path, ["checkout", "-b", branch]);
-    } catch {
-      // Branch may already exist.
-    }
-  }
-  await ensureInitialCommit(path);
-}
-
-async function getOriginRepo(path: string): Promise<string | null> {
-  try {
-    const remote = await runGit(path, ["remote", "get-url", "origin"]);
-    return extractRepoNameFromGitUrl(remote) ?? remote;
-  } catch {
-    return null;
-  }
-}
-
-function toProjectMap(value: unknown): Record<string, unknown> {
-  return normalizeProjectConfigMap(value);
-}
-
-function deriveDisplayName(projectId: string): string {
-  const humanized = projectId
-    .replace(/[-_]+/g, " ")
-    .trim();
-  if (humanized.length === 0) return projectId;
-  return humanized.replace(/\b\w/g, (char) => char.toUpperCase());
-}
-
-function buildProjectPayload(args: {
-  projectId: string;
-  path: string;
-  repo: string;
-  defaultBranch: string;
-  agent: string;
-  agentModel?: string | null;
-  agentReasoningEffort?: string | null;
-  sessionPrefix: string;
-  useWorktree: boolean;
-}): Record<string, unknown> {
-  return buildProjectConfigRecord({
-    projectId: args.projectId,
-    displayName: deriveDisplayName(args.projectId),
-    path: args.path,
-    repo: args.repo,
-    defaultBranch: args.defaultBranch,
-    agent: args.agent,
-    agentModel: args.agentModel ?? null,
-    agentReasoningEffort: args.agentReasoningEffort ?? null,
-    sessionPrefix: args.sessionPrefix,
-    workspace: args.useWorktree ? "worktree" : "local",
-    runtime: "tmux",
-    scm: args.repo.includes("/") ? "github" : null,
-  });
-}
-
-function getExistingPathBasenames(existingPaths: string[]): Set<string> {
-  return new Set(existingPaths.map((path) => basename(expandHome(path))).filter(Boolean));
-}
-
-function getExistingSessionPrefixes(
-  projects: Record<string, { path: string; sessionPrefix?: string }>,
-): Set<string> {
-  const prefixes = new Set<string>();
-  for (const project of Object.values(projects)) {
-    const current = typeof project.sessionPrefix === "string" && project.sessionPrefix.trim().length > 0
-      ? project.sessionPrefix.trim()
-      : generateSessionPrefix(basename(expandHome(project.path)));
-    if (current) prefixes.add(current);
-  }
-  return prefixes;
-}
-
-function createUniqueSessionPrefix(
-  projectPath: string,
-  projects: Record<string, { path: string; sessionPrefix?: string }>,
-): string {
-  const used = getExistingSessionPrefixes(projects);
-  const base = generateSessionPrefix(basename(projectPath));
-  if (!used.has(base)) return base;
-
-  let suffix = 2;
-  while (used.has(`${base}${suffix}`)) {
-    suffix += 1;
-  }
-  return `${base}${suffix}`;
-}
-
-async function writeProjectToConfig(args: {
-  configPath: string;
-  projectId: string;
-  projectData: Record<string, unknown>;
-}): Promise<void> {
-  const originalConfigRaw = await readFile(args.configPath, "utf8");
-  const parsed = (parse(originalConfigRaw) ?? {}) as MutableConfig;
-  const nextRoot: MutableConfig =
-    parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? { ...parsed }
-      : {};
-
-  const nextProjects = toProjectMap(nextRoot.projects);
-  nextProjects[args.projectId] = args.projectData;
-  nextRoot.projects = nextProjects;
-  await normalizeRootProjectPaths(nextRoot);
-
-  const updatedYaml = stringify(nextRoot, {
-    lineWidth: 0,
-  });
-
-  await writeFile(args.configPath, updatedYaml, "utf8");
-
-  try {
-    invalidateServicesCache("workspace added");
-    await getServices();
-  } catch (err) {
-    await writeFile(args.configPath, originalConfigRaw, "utf8");
-    invalidateServicesCache("workspace add rollback");
-    throw err;
-  }
-}
-
-async function ensureProjectBoard(args: {
-  path: string;
-  projectId: string;
-  displayName: string;
-}): Promise<void> {
-  const boardPath = resolve(args.path, "CONDUCTOR.md");
-  const boardStats = await stat(boardPath).catch(() => null);
-  if (boardStats?.isFile()) {
-    return;
-  }
-
-  await writeFile(boardPath, buildConductorBoard(args.projectId, args.displayName), "utf8");
-}
+import { guardedProxyRoute } from "@/lib/proxyRoutes";
 
 export const dynamic = "force-dynamic";
 
-/**
- * GET /api/workspaces
- *
- * Returns all configured projects/workspaces from conductor.yaml.
- */
-export async function GET() {
-  const denied = await guardApiAccess(undefined, "viewer");
-  if (denied) return denied;
-
-  try {
-    const { config } = await getServices();
-    const workspaces = Object.entries(config.projects).map(([id, project]) => ({
-      id,
-      path: project.path,
-      repo: project.repo ?? null,
-      defaultBranch: project.defaultBranch ?? "main",
-      agent: project.agent ?? config.defaults.agent,
-      workspace: project.workspace ?? config.defaults.workspace,
-    }));
-    return NextResponse.json({ workspaces });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Failed to list workspaces";
-    return NextResponse.json({ error: message }, { status: 500 });
-  }
-}
-
-/**
- * POST /api/workspaces
- *
- * Adds a new project to conductor.yaml and prepares the backing repo path.
- * Supports both remote git clone and local/non-git folders.
- */
-export async function POST(request: NextRequest) {
-  const denied = await guardApiAccess(request, "operator");
-  if (denied) return denied;
-  const deniedAction = guardApiActionAccess(request);
-  if (deniedAction) return deniedAction;
-
-  const body = (await request.json().catch(() => null)) as WorkspaceRequestBody | null;
-  if (!body) {
-    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
-  }
-
-  const mode = asNonEmptyString(body.mode) as WorkspaceCreateMode | null;
-  if (mode !== "git" && mode !== "local") {
-    return NextResponse.json({ error: "mode must be either 'git' or 'local'" }, { status: 400 });
-  }
-
-  const requestedDefaultBranchRaw = asNonEmptyString(body.defaultBranch);
-  const fallbackDefaultBranch = requestedDefaultBranchRaw ?? "main";
-  const useWorktree = body.useWorktree !== false;
-  const gitUrl = asNonEmptyString(body.gitUrl);
-  const rawPath = asNonEmptyString(body.path);
-  const initializeGit = body.initializeGit === true;
-
-  try {
-    const { config } = await getServices();
-    const configPath = config.configPath;
-    if (!configPath) {
-      return NextResponse.json(
-        { error: "Unable to resolve conductor config path" },
-        { status: 500 },
-      );
-    }
-
-    const requestedAgent = asNonEmptyString(body.agent) ?? config.defaults.agent;
-    const existingProjectIds = new Set(Object.keys(config.projects));
-    const existingProjectPaths = Object.values(config.projects).map((project) => project.path);
-    const existingPathBasenames = getExistingPathBasenames(existingProjectPaths);
-
-    if (mode === "git") {
-      if (!gitUrl) {
-        return NextResponse.json({ error: "gitUrl is required for mode=git" }, { status: 400 });
-      }
-
-      const initialProjectId = deriveProjectIdFromInputs({
-        providedId: asNonEmptyString(body.projectId),
-        gitUrl,
-        path: rawPath,
-      });
-      const projectId = ensureUniqueProjectId(initialProjectId, existingProjectIds);
-
-      const targetPath = rawPath
-        ? expandHome(rawPath)
-        : resolve(inferBaseProjectsDir(existingProjectPaths), projectId);
-      const targetBasename = basename(targetPath);
-
-      if (existingPathBasenames.has(targetBasename)) {
-        return NextResponse.json(
-          {
-            error: `A project already uses basename '${targetBasename}'. Choose a different folder name.`,
-          },
-          { status: 409 },
-        );
-      }
-
-      await mkdir(dirname(targetPath), { recursive: true });
-
-      const targetStats = await stat(targetPath).catch(() => null);
-      if (targetStats) {
-        if (!targetStats.isDirectory()) {
-          return NextResponse.json(
-            { error: "Target path exists and is not a directory" },
-            { status: 409 },
-          );
-        }
-
-        if (!(await isGitRepository(targetPath))) {
-          return NextResponse.json(
-            { error: "Target path already exists and is not a git repository" },
-            { status: 409 },
-          );
-        }
-      } else {
-        await execFileAsync("git", ["clone", gitUrl, targetPath], { timeout: 120_000 });
-      }
-
-      const detectedDefaultBranch = await detectDefaultBranch(targetPath, fallbackDefaultBranch);
-      const defaultBranch = requestedDefaultBranchRaw ?? detectedDefaultBranch;
-      const repoValue = extractRepoNameFromGitUrl(gitUrl) ?? gitUrl;
-      const sessionPrefix = createUniqueSessionPrefix(targetPath, config.projects);
-      const agentModel = await getResolvedDefaultAgentModel(requestedAgent, config.preferences?.modelAccess ?? null);
-      const agentReasoningEffort = await getResolvedDefaultAgentReasoningEffort(
-        requestedAgent,
-        config.preferences?.modelAccess ?? null,
-        agentModel,
-      );
-
-      await writeProjectToConfig({
-        configPath,
-        projectId,
-        projectData: buildProjectPayload({
-          projectId,
-          path: targetPath,
-          repo: repoValue,
-          defaultBranch,
-          agent: requestedAgent,
-          agentModel,
-          agentReasoningEffort,
-          sessionPrefix,
-          useWorktree,
-        }),
-      });
-      await ensureProjectBoard({
-        path: targetPath,
-        projectId,
-        displayName: deriveDisplayName(projectId),
-      });
-      {
-        const { config: refreshedConfig, registry } = await getServices();
-        await syncProjectLocalConfig(refreshedConfig as unknown as Record<string, unknown>, projectId);
-        syncWorkspaceSupportFiles(refreshedConfig, {
-          agentNames: registry.list("agent").map((agent) => agent.name),
-        });
-      }
-
-      return NextResponse.json(
-        {
-          project: {
-            id: projectId,
-            path: targetPath,
-            repo: repoValue,
-            defaultBranch,
-            agent: requestedAgent,
-            workspace: useWorktree ? "worktree" : "local",
-          },
-        },
-        { status: 201 },
-      );
-    }
-
-    if (!rawPath) {
-      return NextResponse.json({ error: "path is required for mode=local" }, { status: 400 });
-    }
-
-    const localPath = expandHome(rawPath);
-    const localStats = await stat(localPath).catch(() => null);
-    if (!localStats || !localStats.isDirectory()) {
-      return NextResponse.json(
-        { error: "path must point to an existing directory" },
-        { status: 400 },
-      );
-    }
-
-    const localBasename = basename(localPath);
-    if (existingPathBasenames.has(localBasename)) {
-      return NextResponse.json(
-        { error: `A project already uses basename '${localBasename}'. Choose a different folder.` },
-        { status: 409 },
-      );
-    }
-
-    let gitRepo = await isGitRepository(localPath);
-    if (!gitRepo && initializeGit) {
-      await initializeGitRepository(localPath, fallbackDefaultBranch);
-      gitRepo = true;
-    }
-
-    if (!gitRepo) {
-      return NextResponse.json(
-        {
-          error: "Selected folder is not a git repository. Enable git initialization to use it as a workspace.",
-        },
-        { status: 400 },
-      );
-    }
-
-    const detectedDefaultBranch = await detectDefaultBranch(localPath, fallbackDefaultBranch);
-    const defaultBranch = requestedDefaultBranchRaw ?? detectedDefaultBranch;
-    const initialProjectId = deriveProjectIdFromInputs({
-      providedId: asNonEmptyString(body.projectId),
-      gitUrl: null,
-      path: localPath,
-    });
-    const projectId = ensureUniqueProjectId(initialProjectId, existingProjectIds);
-
-    const repoValue = (await getOriginRepo(localPath)) ?? `local-${projectId}`;
-    const sessionPrefix = createUniqueSessionPrefix(localPath, config.projects);
-    const agentModel = await getResolvedDefaultAgentModel(requestedAgent, config.preferences?.modelAccess ?? null);
-    const agentReasoningEffort = await getResolvedDefaultAgentReasoningEffort(
-      requestedAgent,
-      config.preferences?.modelAccess ?? null,
-      agentModel,
-    );
-
-    await writeProjectToConfig({
-      configPath,
-      projectId,
-      projectData: buildProjectPayload({
-        projectId,
-        path: localPath,
-        repo: repoValue,
-        defaultBranch,
-        agent: requestedAgent,
-        agentModel,
-        agentReasoningEffort,
-        sessionPrefix,
-        useWorktree,
-      }),
-    });
-    await ensureProjectBoard({
-      path: localPath,
-      projectId,
-      displayName: deriveDisplayName(projectId),
-    });
-    {
-      const { config: refreshedConfig, registry } = await getServices();
-      await syncProjectLocalConfig(refreshedConfig as unknown as Record<string, unknown>, projectId);
-      syncWorkspaceSupportFiles(refreshedConfig, {
-        agentNames: registry.list("agent").map((agent) => agent.name),
-      });
-    }
-
-    return NextResponse.json(
-      {
-        project: {
-          id: projectId,
-          path: localPath,
-          repo: repoValue,
-          defaultBranch,
-          agent: requestedAgent,
-          workspace: useWorktree ? "worktree" : "local",
-        },
-      },
-      { status: 201 },
-    );
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Failed to create workspace";
-    return NextResponse.json({ error: message }, { status: 500 });
-  }
-}
+export const GET = guardedProxyRoute("/api/workspaces", { role: "viewer" });
+export const POST = guardedProxyRoute("/api/workspaces", { role: "operator", requireActionGuard: true });

package/web/.next/standalone/packages/web/src/app/unlock/UnlockForm.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { type FormEvent, useState } from "react";
+import { type FormEvent, useEffect, useRef, useState } from "react";
 import { useRouter } from "next/navigation";
 
 type UnlockFormProps = {
@@ -13,9 +13,9 @@ export function UnlockForm({ initialError, nextPath }: UnlockFormProps) {
   const [token, setToken] = useState("");
   const [submitting, setSubmitting] = useState(false);
   const [error, setError] = useState<string | null>(initialError);
+  const attemptedHashUnlockRef = useRef(false);
 
-  async function handleSubmit(event: FormEvent<HTMLFormElement>): Promise<void> {
-    event.preventDefault();
+  async function submitToken(submittedToken: string): Promise<void> {
     setSubmitting(true);
     setError(null);
 
@@ -25,7 +25,7 @@ export function UnlockForm({ initialError, nextPath }: UnlockFormProps) {
         headers: {
           "Content-Type": "application/json",
         },
-        body: JSON.stringify({ token }),
+        body: JSON.stringify({ token: submittedToken }),
       });
 
       if (!response.ok) {
@@ -41,6 +41,27 @@ export function UnlockForm({ initialError, nextPath }: UnlockFormProps) {
     }
   }
 
+  async function handleSubmit(event: FormEvent<HTMLFormElement>): Promise<void> {
+    event.preventDefault();
+    await submitToken(token);
+  }
+
+  useEffect(() => {
+    if (attemptedHashUnlockRef.current) return;
+    attemptedHashUnlockRef.current = true;
+
+    const hash = window.location.hash.startsWith("#")
+      ? window.location.hash.slice(1)
+      : window.location.hash;
+    const hashToken = new URLSearchParams(hash).get("token")?.trim() ?? "";
+    if (!hashToken) return;
+
+    setToken(hashToken);
+    const nextUrl = `${window.location.pathname}${window.location.search}`;
+    window.history.replaceState(null, "", nextUrl);
+    void submitToken(hashToken);
+  }, []);
+
   return (
     <form className="mt-6 space-y-4" onSubmit={(event) => void handleSubmit(event)}>
       <label className="block space-y-2">

package/web/.next/standalone/packages/web/src/components/board/WorkspaceKanban.tsx

@@ -286,15 +286,15 @@ export function WorkspaceKanban({ projectId, defaultAgent, agentOptions }: Works
 
   useEffect(() => {
     if (!orderedAgentOptions.includes(agent)) {
-      setAgent(orderedAgentOptions[0] ?? "qwen-code");
+      setAgent(orderedAgentOptions[0] ?? defaultAgent);
     }
-  }, [agent, orderedAgentOptions]);
+  }, [agent, defaultAgent, orderedAgentOptions]);
 
   useEffect(() => {
     if (!orderedAgentOptions.includes(editAgent)) {
-      setEditAgent(orderedAgentOptions[0] ?? "qwen-code");
+      setEditAgent(orderedAgentOptions[0] ?? defaultAgent);
     }
-  }, [editAgent, orderedAgentOptions]);
+  }, [defaultAgent, editAgent, orderedAgentOptions]);
 
   useEffect(() => {
     if (!composerOpen || !projectId) return;
@@ -625,7 +625,7 @@ export function WorkspaceKanban({ projectId, defaultAgent, agentOptions }: Works
     setEditRole(role);
     setEditTitle(nextTitle);
     setEditDescription(nextDescription);
-    setEditAgent(task.agent ?? orderedAgentOptions[0] ?? "qwen-code");
+    setEditAgent(task.agent ?? orderedAgentOptions[0] ?? defaultAgent);
     setEditTaskType(task.type ?? "feature");
     setEditPriority(task.priority ?? "normal");
     setEditLinkedSession(task.attemptRef ?? "");
@@ -722,15 +722,15 @@ export function WorkspaceKanban({ projectId, defaultAgent, agentOptions }: Works
           </div>
         ) : (
           <div
-            className="grid min-w-[980px] gap-0 rounded-[4px] border border-[var(--vk-border)]"
+            className="flex min-w-0 flex-col gap-3 rounded-[4px] border border-[var(--vk-border)] lg:grid lg:gap-0"
             style={{ gridTemplateColumns: `repeat(${Math.max(visibleColumns.length, 1)}, minmax(240px, 1fr))` }}
           >
             {visibleColumns.map((column, columnIndex) => (
               <article
                 key={column.role}
                 className={cn(
-                  "flex min-h-[540px] flex-col border-r border-[var(--vk-border)] bg-[var(--vk-bg-panel)]",
-                  columnIndex === visibleColumns.length - 1 && "border-r-0",
+                  "flex min-h-[320px] flex-col border-b border-[var(--vk-border)] bg-[var(--vk-bg-panel)] lg:min-h-[540px] lg:border-b-0 lg:border-r",
+                  columnIndex === visibleColumns.length - 1 && "border-b-0 lg:border-r-0",
                 )}
               >
                 <header className="flex h-[41px] items-center border-b border-[var(--vk-border)] px-2">