Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(workspace): sanitize slugs to URL-safe kebab-case + heal legacy rows

Gener7276ef0e4a85
diff --git a/src/cli/commands/workspace.ts b/src/cli/commands/workspace.ts
index ff7d24476..48432de24 100644
--- a/src/cli/commands/workspace.ts
+++ b/src/cli/commands/workspace.ts
@@ -1,6 +1,6 @@
import { Command } from "commander";
import { readFileSync } from "fs";
-import { toAlookAddress } from "@alook/shared";
+import { toAlookAddress, sanitizeSlug } from "@alook/shared";
import { APIClient } from "../lib/client.js";
import { cmdPrefix } from "../lib/env.js";
import { printJSON } from "../lib/output.js";
@@ -18,14 +18,6 @@ interface WorkspaceResponse {
name: string;
}
-function slugify(name: string): string {
- return name
- .toLowerCase()
- .replace(/[^a-z0-9]+/g, "-")
- .replace(/^-|-$/g, "")
- .slice(0, 60);
-}
-
interface StudioResponse {
studio: { name: string };
workspace: { id: string; name: string; slug: string };
@@ -60,7 +52,7 @@ async function resolveWorkspaceId(client: APIClient, configName?: string): Promi
// No empty workspace — create one
const wsName = configName || "Personal";
try {
- const newWs = await client.postJSON<{ id: string; name: string }>("/api/workspaces", { name: wsName, slug: slugify(wsName) });
+ const newWs = await client.postJSON<{ id: string; name: string }>("/api/workspaces", { name: wsName, slug: sanitizeSlug(wsName) });
console.log(`Created workspace: ${newWs.name} (${newWs.id})`);
return { workspaceId: newWs.id, created: true };
} catch (err) {
@@ -215,7 +207,7 @@ export function workspaceCommand(): Command {
if (agents.length > 0) {
console.log("Current workspace has existing agents. Creating a new workspace...");
const wsName = opts.name || config.name || "New Workspace";
- const newWs = await targetClient.postJSON<{ id: string; name: string }>("/api/workspaces", { name: wsName, slug: slugify(wsName) });
+ const newWs = await targetClient.postJSON<{ id: string; name: string }>("/api/workspaces", { name: wsName, slug: sanitizeSlug(wsName) });
targetWorkspaceId = newWs.id;
targetClient = new APIClient(serverUrl, token, targetWorkspaceId);
console.log(`Created workspace: ${newWs.name} (${newWs.id})`);
diff --git a/src/email-worker/src/imap-poller-do.test.ts b/src/email-worker/src/imap-poller-do.test.ts
index d295fa752..3bc9bc3ab 100644
--- a/src/email-worker/src/imap-poller-do.test.ts
+++ b/src/email-worker/src/imap-poller-do.test.ts
@@ -48,6 +48,7 @@ vi.mock("postal-mime", () => ({
let nanoidCounter = 0
vi.mock("nanoid", () => ({
nanoid: (len?: number) => `mock-${++nanoidCounter}`,
+ customAlphabet: () => () => `mock-${++nanoidCounter}`,
}))
vi.mock("@alook/shared/crypto", () => ({
diff --git a/src/email-worker/src/index.test.ts b/src/email-worker/src/index.test.ts
index 28d962978..e5f735ca8 100644
--- a/src/email-worker/src/index.test.ts
+++ b/src/email-worker/src/index.test.ts
@@ -29,6 +29,7 @@ vi.mock("@alook/shared/crypto", () => ({
let nanoidCounter = 0
vi.mock("nanoid", () => ({
nanoid: () => `mock-id-${++nanoidCounter}`,
+ customAlphabet: () => () => `mock-id-${++nanoidCounter}`,
}))
// Mock cloudflare:email — capture the raw MIME passed to the CF SEND_EMAIL binding.
diff --git a/src/shared/src/index.ts b/src/shared/src/index.ts
index dddf9dda2..59c65925a 100644
--- a/src/shared/src/index.ts
+++ b/src/shared/src/index.ts
@@ -536,7 +536,7 @@ export { isValidToken, isValidEmail } from "./utils/validation";
export { escapeLikePattern } from "./utils/sql-like";
export { isOnline, formatStatus, isPresenceOnline, isPresenceOffline } from "./utils/status";
export { isUniqueConstraintError } from "./utils/db-errors";
-export { generateWorkspaceSlug } from "./utils/slug";
+export { generateWorkspaceSlug, sanitizeSlug, slugSuffix } from "./utils/slug";
export { truncateTitle, stripInlineMarkup, deriveThreadName } from "./utils/title";
export {
canManageServer,
diff --git a/src/shared/src/schemas.test.ts b/src/shared/src/schemas.test.ts
index 4cd7cda13..00ec6658c 100644
--- a/src/shared/src/schemas.test.ts
+++ b/src/shared/src/schemas.test.ts
@@ -4,6 +4,8 @@ import {
CommunityBotPatchRequestSchema,
AgentTypingMessageSchema,
AgentTypingStopMessageSchema,
+ CreateWorkspaceRequestSchema,
+ UpdateWorkspaceRequestSchema,
} from "./schemas"
function validCreatePayload(image?: string) {
@@ -149,3 +151,43 @@ describe("AgentTypingStopMessageSchema", () => {
expect(res.success).toBe(false)
})
})
+
+describe("CreateWorkspaceRequestSchema slug sanitization", () => {
+ it("sanitizes a dirty slug to ASCII kebab-case", () => {
+ const res = CreateWorkspaceRequestSchema.parse({ name: "Acme", slug: "My Company" })
+ expect(res.slug).toBe("my-company")
+ })
+
+ it("defaults an omitted slug to empty (route generates)", () => {
+ const res = CreateWorkspaceRequestSchema.parse({ name: "Acme" })
+ expect(res.slug).toBe("")
+ })
+
+ it("yields empty for an unsanitizable slug (route falls back)", () => {
+ const res = CreateWorkspaceRequestSchema.parse({ name: "Acme", slug: "🎉" })
+ expect(res.slug).toBe("")
+ })
+})
+
+describe("UpdateWorkspaceRequestSchema slug sanitization", () => {
+ it("sanitizes a provided slug", () => {
+ const res = UpdateWorkspaceRequestSchema.parse({ slug: "New Slug" })
+ expect(res.slug).toBe("new-slug")
+ })
+
+ it("transforms an unsanitizable slug to empty (route rejects)", () => {
+ const res = UpdateWorkspaceRequestSchema.parse({ slug: "🎉" })
+ expect(res.slug).toBe("")
+ })
+
+ it("leaves slug undefined and does not throw when omitted", () => {
+ const res = UpdateWorkspaceRequestSchema.parse({ name: "x" })
+ expect(res.slug).toBeUndefined()
+ expect(res.name).toBe("x")
+ })
+
+ it("accepts and truncates a very long messy slug (no max rejection)", () => {
+ const res = UpdateWorkspaceRequestSchema.parse({ slug: "A very long name ".repeat(20) })
+ expect(res.slug!.length).toBeLessThanOrEqual(60)
+ })
+})
diff --git a/src/shared/src/schemas.ts b/src/shared/src/schemas.ts
index 7b14cd034..3f6a1a723 100644
--- a/src/shared/src/schemas.ts
+++ b/src/shared/src/schemas.ts
@@ -1,5 +1,6 @@
import { z } from "zod";
import { IssueStatus, TASK_TYPES } from "./constants";
+import { sanitizeSlug } from "./utils/slug";
import { MAX_ATTACHMENTS_PER_MESSAGE, MAX_MESSAGE_CONTENT_LENGTH } from "./constants/community";
// ---------------------------------------------------------------------------
@@ -685,7 +686,7 @@ export type UpdateMemberRequest = z.infer<typeof UpdateMemberRequestSchema>;
export const CreateWorkspaceRequestSchema = z.object({
name: z.string().min(1, "name is required"),
- slug: z.string().optional().default(""),
+ slug: z.string().optional().default("").transform(sanitizeSlug),
});
export type CreateWorkspaceRequest = z.infer<
typeof CreateWorkspaceRequestSchema
@@ -693,7 +694,7 @@ export type CreateWorkspaceRequest = z.infer<
export const UpdateWorkspaceRequestSchema = z.object({
name: z.string().min(1, "name is required").max(100).trim().optional(),
- slug: z.string().min(1, "slug is required").max(100).trim().toLowerCase().optional(),
+ slug: z.string().min(1, "slug is required").trim().toLowerCase().transform(sanitizeSlug).optional(),
});
export type UpdateWorkspaceRequest = z.infer<typeof UpdateWorkspaceRequestSchema>;
diff --git a/src/shared/src/utils/slug.ts b/src/shared/src/utils/slug.ts
index 36bf8d54c..4c90684c0 100644
--- a/src/shared/src/utils/slug.ts
+++ b/src/shared/src/utils/slug.ts
@@ -1,5 +1,27 @@
-import { nanoid } from "nanoid";
+import { customAlphabet } from "nanoid";
+
+const slugId = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyz");
export function generateWorkspaceSlug(): string {
- return `company-${nanoid(8)}`;
+ return `company-${slugId(8)}`;
+}
+
+/**
+ * Normalize an arbitrary string into a URL-safe workspace slug: ASCII
+ * kebab-case, lowercase, runs of anything outside `[a-z0-9]` collapse to a
+ * single `-`, no leading/trailing `-`, capped at 60 chars (with the trailing
+ * `-` a mid-run truncation may leave stripped again). Input that has no
+ * `[a-z0-9]` characters (e.g. `"总部"`, `"!!!"`, `""`) returns `""` — callers
+ * must treat empty as "generate a fallback" (create) or "reject" (update).
+ */
+export function sanitizeSlug(input: string): string {
+ return input
+ .toLowerCase()
+ .replace(/[^a-z0-9]+/g, "-")
+ .replace(/^-+|-+$/g, "")
+ .slice(0, 60)
+ .replace(/-+$/g, "");
}
+
+/** Lowercase-alnum id for slug conflict-retry suffixes. */
+export const slugSuffix = slugId;
diff --git a/src/shared/test/utils/slug.test.ts b/src/shared/test/utils/slug.test.ts
index 9435ad8db..b244b7c24 100644
--- a/src/shared/test/utils/slug.test.ts
+++ b/src/shared/test/utils/slug.test.ts
@@ -1,5 +1,5 @@
import { describe, it, expect } from "vitest";
-import { generateWorkspaceSlug } from "../../src/utils/slug";
+import { generateWorkspaceSlug, sanitizeSlug } from "../../src/utils/slug";
describe("generateWorkspaceSlug", () => {
it("starts with 'company-' prefix", () => {
@@ -16,4 +16,54 @@ describe("generateWorkspaceSlug", () => {
const slugs = new Set(Array.from({ length: 100 }, () => generateWorkspaceSlug()));
expect(slugs.size).toBe(100);
});
+
+ it("emits only lowercase alnum after the prefix (no uppercase or '_')", () => {
+ for (let i = 0; i < 200; i++) {
+ expect(generateWorkspaceSlug()).toMatch(/^company-[a-z0-9]{8}$/);
+ }
+ });
+});
+
+describe("sanitizeSlug", () => {
+ it("lowercases and hyphenates spaces", () => {
+ expect(sanitizeSlug("My Company")).toBe("my-company");
+ });
+
+ it("trims and collapses internal whitespace", () => {
+ expect(sanitizeSlug(" hello world ")).toBe("hello-world");
+ });
+
+ it("turns URL-reserved chars into separators", () => {
+ expect(sanitizeSlug("a/b#c?d")).toBe("a-b-c-d");
+ });
+
+ it("collapses symbol runs to a single hyphen", () => {
+ expect(sanitizeSlug("Foo___Bar!!!Baz")).toBe("foo-bar-baz");
+ });
+
+ it("returns empty for non-ASCII input", () => {
+ expect(sanitizeSlug("总部 🎉")).toBe("");
+ });
+
+ it("returns empty for all-separator or empty input", () => {
+ expect(sanitizeSlug("!!!")).toBe("");
+ expect(sanitizeSlug(" ")).toBe("");
+ expect(sanitizeSlug("")).toBe("");
+ });
+
+ it("leaves an already-clean slug unchanged", () => {
+ expect(sanitizeSlug("already-clean-slug")).toBe("already-clean-slug");
+ });
+
+ it("truncates to at most 60 chars with no trailing hyphen", () => {
+ const out = sanitizeSlug("a".repeat(70));
+ expect(out.length).toBeLessThanOrEqual(60);
+ expect(out.endsWith("-")).toBe(false);
+ });
+
+ it("does not leave a trailing hyphen when truncation lands on a separator", () => {
+ const out = sanitizeSlug("a".repeat(59) + " tail");
+ expect(out.endsWith("-")).toBe(false);
+ expect(out.length).toBeLessThanOrEqual(60);
+ });
});
diff --git a/src/web/migrations/0063_sanitize_workspace_slugs.sql b/src/web/migrations/0063_sanitize_workspace_slugs.sql
new file mode 100644
index 000000000..fa07061fe
--- /dev/null
+++ b/src/web/migrations/0063_sanitize_workspace_slugs.sql
@@ -0,0 +1,13 @@
+-- Heal workspace slugs that predate server-side sanitization.
+-- A slug is a URL path segment (/w/{slug}); any char outside [a-z0-9-]
+-- (spaces, uppercase, unicode, symbols, '_') breaks the invariant. SQLite has
+-- no regex replace and a partial transform risks UNIQUE(slug) collisions, so we
+-- regenerate illegal slugs to a guaranteed-safe, collision-free 'company-<hex>'
+-- value. Owners can set a readable slug in settings after.
+-- GLOB is case-sensitive, so uppercase letters ARE caught by [^a-z0-9-]; the
+-- trailing '-' in the class is a literal and is correctly allowed.
+-- Idempotent: clean slugs never match the WHERE, so re-running is a no-op.
+UPDATE workspace
+SET slug = 'company-' || lower(hex(randomblob(4))),
+ updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+WHERE slug GLOB '*[^a-z0-9-]*';
diff --git a/src/web/src/app/(app)/w/[slug]/settings/general-tab.tsx b/src/web/src/app/(app)/w/[slug]/settings/general-tab.tsx
index 4077efdef..957f2642e 100644
--- a/src/web/src/app/(app)/w/[slug]/settings/general-tab.tsx
+++ b/src/web/src/app/(app)/w/[slug]/settings/general-tab.tsx
@@ -3,6 +3,7 @@
import { useCallback, useEffect, useState } from "react";
import { toast } from "sonner";
import { useRouter } from "next/navigation";
+import { sanitizeSlug } from "@alook/shared";
import { useWorkspace } from "@/contexts/workspace-context";
import { useSession } from "@/lib/auth-client";
import {
@@ -76,9 +77,12 @@ export function GeneralTab() {
workspaceName !== savedWorkspaceName || workspaceSlug !== savedWorkspaceSlug;
const handleSaveWorkspace = async () => {
+ const cleanSlug = sanitizeSlug(workspaceSlug);
+ setWorkspaceSlug(cleanSlug);
+
const nextErrors = validateWorkspaceForm({
name: workspaceName,
- slug: workspaceSlug,
+ slug: cleanSlug,
});
setWorkspaceErrors(nextErrors);
if (hasWorkspaceFormErrors(nextErrors)) return;
@@ -87,7 +91,7 @@ export function GeneralTab() {
try {
const updated = await updateWorkspace(workspaceId, {
name: workspaceName.trim(),
- slug: workspaceSlug.trim(),
+ slug: cleanSlug,
});
trackSettingsUpdated({ setting_tab: "general" });
setSavedWorkspaceName(updated.name);
@@ -168,12 +172,13 @@ export function GeneralTab() {
id="workspace-slug"
value={workspaceSlug}
onChange={(e) => {
- const nextSlug = e.target.value;
+ const nextSlug = e.target.value.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
setWorkspaceSlug(nextSlug);
if (workspaceErrors.slug && nextSlug.trim()) {
setWorkspaceErrors((prev) => ({ ...prev, slug: undefined }));
}
}}
+ onBlur={() => setWorkspaceSlug((s) => sanitizeSlug(s))}
placeholder="workspace-slug"
aria-invalid={Boolean(workspaceErrors.slug)}
aria-describedby={workspaceErrors.slug ? "workspace-slug-error" : undefined}
diff --git a/src/web/src/app/api/agents/recruit/route.test.ts b/src/web/src/app/api/agents/recruit/route.test.ts
index de3f502f6..73a731e15 100644
--- a/src/web/src/app/api/agents/recruit/route.test.ts
+++ b/src/web/src/app/api/agents/recruit/route.test.ts
@@ -5,7 +5,7 @@ vi.mock("@opennextjs/cloudflare", () => ({
getCloudflareContext: vi.fn(() => ({ env: { DB: {}, EMAIL_BUCKET: { put: vi.fn() }, WORKER_SELF_REFERENCE: { fetch: vi.fn() } } })),
}));
vi.mock("@/lib/db", () => ({ getDb: vi.fn(() => ({})) }));
-vi.mock("nanoid", () => ({ nanoid: vi.fn(() => "id123") }));
+vi.mock("nanoid", () => ({ nanoid: vi.fn(() => "id123"), customAlphabet: () => () => "id123" }));
vi.mock("unique-names-generator", () => ({
uniqueNamesGenerator: vi.fn(() => "Robin"),
names: [],
diff --git a/src/web/src/app/api/artifacts/upload/route.test.ts b/src/web/src/app/api/artifacts/upload/route.test.ts
index cec6e5532..bb11c17aa 100644
--- a/src/web/src/app/api/artifacts/upload/route.test.ts
+++ b/src/web/src/app/api/artifacts/upload/route.test.ts
@@ -6,7 +6,7 @@ vi.mock("@opennextjs/cloudflare", () => ({
getCloudflareContext: vi.fn(() => ({ env: { DB: {}, EMAIL_BUCKET: { put: mockPut } } })),
}));
vi.mock("@/lib/db", () => ({ getDb: vi.fn(() => ({})) }));
-vi.mock("nanoid", () => ({ nanoid: vi.fn(() => "xyz") }));
+vi.mock("nanoid", () => ({ nanoid: vi.fn(() => "xyz"), customAlphabet: () => () => "xyz" }));
const mockGetConversation = vi.fn();
const mockCreateArtifact = vi.fn();
diff --git a/src/web/src/app/api/meeting/callback/route.test.ts b/src/web/src/app/api/meeting/callback/route.test.ts
index fb5f0cad5..85534f8a8 100644
--- a/src/web/src/app/api/meeting/callback/route.test.ts
+++ b/src/web/src/app/api/meeting/callback/route.test.ts
@@ -54,7 +54,7 @@ vi.mock("@/lib/logger", () => ({
log: { warn: vi.fn(), info: vi.fn(), error: vi.fn(), debug: vi.fn() },
}));
-vi.mock("nanoid", () => ({ nanoid: () => "test-nanoid-123" }));
+vi.mock("nanoid", () => ({ nanoid: () => "test-nanoid-123", customAlphabet: () => () => "test-nanoid-123" }));
import { POST } from "./route";
diff --git a/src/web/src/app/api/studios/check-name/route.ts b/src/web/src/app/api/studios/check-name/route.ts
index d94710f14..659968d35 100644
--- a/src/web/src/app/api/studios/check-name/route.ts
+++ b/src/web/src/app/api/studios/check-name/route.ts
@@ -1,18 +1,10 @@
import { NextRequest } from "next/server";
-import { queries } from "@alook/shared";
+import { queries, sanitizeSlug } from "@alook/shared";
import { getDb } from "@/lib/db";
import { withAuth } from "@/lib/middleware/auth";
import { withWorkspaceMember } from "@/lib/middleware/workspace";
import { writeJSON, writeError } from "@/lib/middleware/helpers";
-function slugify(name: string): string {
- return name
- .toLowerCase()
- .replace(/[^a-z0-9]+/g, "-")
- .replace(/^-|-$/g, "")
- .slice(0, 60);
-}
-
export const GET = withAuth(async (req: NextRequest, ctx) => {
const wsParam = req.nextUrl.searchParams.get("workspace_id");
let currentWorkspaceId: string | null = null;
@@ -28,7 +20,7 @@ export const GET = withAuth(async (req: NextRequest, ctx) => {
return writeError("name query parameter is required", 400);
}
- const slug = slugify(name.trim());
+ const slug = sanitizeSlug(name.trim());
if (!slug) {
return writeError("name produces an invalid slug", 400);
}
diff --git a/src/web/src/app/api/studios/route.ts b/src/web/src/app/api/studios/route.ts
index 700d8df86..dcb5bd2b0 100644
--- a/src/web/src/app/api/studios/route.ts
+++ b/src/web/src/app/api/studios/route.ts
@@ -1,5 +1,5 @@
import { NextRequest } from "next/server";
-import { queries, CreateStudioRequestSchema, isValidHandle, isOnline, TASK_TYPES, toAlookAddress } from "@alook/shared";
+import { queries, CreateStudioRequestSchema, isValidHandle, isOnline, TASK_TYPES, toAlookAddress, sanitizeSlug, slugSuffix } from "@alook/shared";
import { nanoid } from "nanoid";
import { uniqueNamesGenerator, names } from "unique-names-generator";
import { getDb } from "@/lib/db";
@@ -11,14 +11,6 @@ import { randomBeamAvatar } from "@/lib/avatar/seed-url";
import { TaskService } from "@/lib/services/task";
import { invalidate, cached, cacheKeys } from "@/lib/cache";
-function slugify(name: string): string {
- return name
- .toLowerCase()
- .replace(/[^a-z0-9]+/g, "-")
- .replace(/^-|-$/g, "")
- .slice(0, 60);
-}
-
function generateUniqueHandleFromSet(
handleSet: Set<string>,
baseName: string,
@@ -69,7 +61,7 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {
if (body.name && ws.memberRole === "owner") {
const existingAgents = await queries.agent.listAgents(db, ws.workspaceId);
- const newSlug = slugify(body.name);
+ const newSlug = sanitizeSlug(body.name);
if (existingAgents.length === 0 && newSlug) {
let finalSlug = newSlug;
const conflicting = await queries.workspace.getWorkspaceBySlug(db, newSlug);
@@ -85,7 +77,7 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {
break;
}
}
- if (!found) finalSlug = `${newSlug}-${nanoid(6)}`;
+ if (!found) finalSlug = `${newSlug}-${slugSuffix(6)}`;
}
const updated = await queries.workspace.updateWorkspace(db, ws.workspaceId, {
name: body.name.trim(),
diff --git a/src/web/src/app/api/workspaces/[id]/route.test.ts b/src/web/src/app/api/workspaces/[id]/route.test.ts
index 0f3fed737..512e47967 100644
--- a/src/web/src/app/api/workspaces/[id]/route.test.ts
+++ b/src/web/src/app/api/workspaces/[id]/route.test.ts
@@ -160,6 +160,39 @@ describe("PATCH /api/workspaces/[id]", () => {
expect(res.status).toBe(400);
});
+ it("sanitizes a dirty slug before updating", async () => {
+ mockUpdateWorkspace.mockResolvedValue({
+ id: "w1",
+ name: "Acme",
+ slug: "new-name",
+ createdAt: "2024-01-01T00:00:00Z",
+ updatedAt: "2024-01-02T00:00:00Z",
+ });
+
+ const req = new NextRequest("http://localhost/api/workspaces/w1", {
+ method: "PATCH",
+ body: JSON.stringify({ slug: "New Name" }),
+ headers: { "Content-Type": "application/json" },
+ });
+ const res = await PATCH(req, { params: Promise.resolve({ id: "w1" }) } as any);
+
+ expect(res.status).toBe(200);
+ expect(mockUpdateWorkspace).toHaveBeenCalledWith({}, "w1", { slug: "new-name" });
+ });
+
+ it("rejects a slug that sanitizes to empty with 400 slug is required", async () => {
+ const req = new NextRequest("http://localhost/api/workspaces/w1", {
+ method: "PATCH",
+ body: JSON.stringify({ slug: "🎉" }),
+ headers: { "Content-Type": "application/json" },
+ });
+ const res = await PATCH(req, { params: Promise.resolve({ id: "w1" }) } as any);
+
+ expect(res.status).toBe(400);
+ expect(await res.json()).toEqual({ error: "slug is required" });
+ expect(mockUpdateWorkspace).not.toHaveBeenCalled();
+ });
+
it("returns 409 when slug is already in use", async () => {
const uniqueErr = Object.assign(new Error("UNIQUE constraint failed"), {});
mockUpdateWorkspace.mockRejectedValue(uniqueErr);
diff --git a/src/web/src/app/api/workspaces/[id]/route.ts b/src/web/src/app/api/workspaces/[id]/route.ts
index b01ff833a..52d893f26 100644
--- a/src/web/src/app/api/workspaces/[id]/route.ts
+++ b/src/web/src/app/api/workspaces/[id]/route.ts
@@ -29,6 +29,7 @@ export const PATCH = withAuth(async (req: NextRequest, ctx) => {
const [body, err] = await parseBody(req, UpdateWorkspaceRequestSchema);
if (err) return err;
+ if (body.slug !== undefined && body.slug === "") return writeError("slug is required", 400);
if (!body.name && !body.slug) return writeError("at least one of name or slug is required", 400);
const db = getDb(ctx.env.DB);
diff --git a/src/web/src/app/api/workspaces/route.test.ts b/src/web/src/app/api/workspaces/route.test.ts
index da34de469..8bdaa9a39 100644
--- a/src/web/src/app/api/workspaces/route.test.ts
+++ b/src/web/src/app/api/workspaces/route.test.ts
@@ -96,6 +96,36 @@ describe("POST /api/workspaces", () => {
});
});
+ it("sanitizes a dirty slug before creating", async () => {
+ mockCreateWorkspace.mockResolvedValue({ id: "w-clean", name: "My Company", slug: "my-company" });
+ mockCreateMember.mockResolvedValue({});
+
+ const req = new NextRequest("http://localhost/api/workspaces", {
+ method: "POST",
+ body: JSON.stringify({ name: "My Company", slug: "My Company" }),
+ headers: { "Content-Type": "application/json" },
+ });
+ const res = await POST(req, {} as any);
+
+ expect(res.status).toBe(201);
+ expect(mockCreateWorkspace.mock.calls[0][1].slug).toBe("my-company");
+ });
+
+ it("falls back to a generated slug when the slug sanitizes to empty", async () => {
+ mockCreateWorkspace.mockResolvedValue({ id: "w-gen", name: "Party", slug: "company-abcd1234" });
+ mockCreateMember.mockResolvedValue({});
+
+ const req = new NextRequest("http://localhost/api/workspaces", {
+ method: "POST",
+ body: JSON.stringify({ name: "Party", slug: "🎉" }),
+ headers: { "Content-Type": "application/json" },
+ });
+ const res = await POST(req, {} as any);
+
+ expect(res.status).toBe(201);
+ expect(mockCreateWorkspace.mock.calls[0][1].slug).toMatch(/^company-[a-z0-9]{8}$/);
+ });
+
it("returns 400 for missing name", async () => {
const req = new NextRequest("http://localhost/api/workspaces", {
method: "POST",
@@ -142,8 +172,8 @@ describe("POST /api/workspaces", () => {
expect(mockCreateWorkspace).toHaveBeenCalledTimes(2);
// First call uses original slug
expect(mockCreateWorkspace.mock.calls[0][1].slug).toBe("dup");
- // Second call uses a suffixed slug
- expect(mockCreateWorkspace.mock.calls[1][1].slug).toMatch(/^dup-.+/);
+ // Second call uses a lowercase-alnum suffixed slug
+ expect(mockCreateWorkspace.mock.calls[1][1].slug).toMatch(/^dup-[a-z0-9]+$/);
});
it("returns 409 after all slug retries exhausted", async () => {
diff --git a/src/web/src/app/api/workspaces/route.ts b/src/web/src/app/api/workspaces/route.ts
index f09c8cee8..f37abe823 100644
--- a/src/web/src/app/api/workspaces/route.ts
+++ b/src/web/src/app/api/workspaces/route.ts
@@ -1,7 +1,6 @@
import { NextRequest } from "next/server";
-import { queries, isUniqueConstraintError, generateWorkspaceSlug, CreateWorkspaceRequestSchema } from "@alook/shared"
+import { queries, isUniqueConstraintError, generateWorkspaceSlug, slugSuffix, CreateWorkspaceRequestSchema } from "@alook/shared"
import { getDb } from "@/lib/db"
-import { nanoid } from "nanoid"
import { withAuth } from "@/lib/middleware/auth";
import { writeJSON, writeError, parseBody } from "@/lib/middleware/helpers";
import { workspaceToResponse } from "@/lib/api/responses";
@@ -20,7 +19,7 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {
if (valErr) return valErr;
const name = body.name.trim();
- const slug = body.slug?.trim() ? body.slug.toLowerCase().trim() : generateWorkspaceSlug();
+ const slug = body.slug || generateWorkspaceSlug();
const suffixLengths = [4, 4, 4, 8, 8, 8, 16, 16, 16];
let candidateSlug = slug;
@@ -39,7 +38,7 @@ export const POST = withAuth(async (req: NextRequest, ctx) => {
if (attempt >= suffixLengths.length) {
return writeError("workspace slug already exists", 409);
}
- candidateSlug = `${slug}-${nanoid(suffixLengths[attempt])}`;
+ candidateSlug = `${slug}-${slugSuffix(suffixLengths[attempt])}`;
}
}
});
diff --git a/src/web/src/lib/api/workspaces.ts b/src/web/src/lib/api/workspaces.ts
index 1d38e88a2..6ac002553 100644
--- a/src/web/src/lib/api/workspaces.ts
+++ b/src/web/src/lib/api/workspaces.ts
@@ -1,4 +1,5 @@
import type { LoginResponse, Workspace } from "@alook/shared";
+import { sanitizeSlug } from "@alook/shared";
import { apiFetch, wsQuery } from "./client";
export const listWorkspaces = () => apiFetch<Workspace[]>("/api/workspaces");
@@ -6,7 +7,7 @@ export const listWorkspaces = () => apiFetch<Workspace[]>("/api/workspaces");
export const createWorkspace = (name: string, slug?: string) =>
apiFetch<Workspace>("/api/workspaces", {
method: "POST",
- body: JSON.stringify({ name, slug: slug || name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "workspace" }),
+ body: JSON.stringify({ name, slug: sanitizeSlug(slug || name) || "workspace" }),
});
export const updateWorkspace = (workspaceId: string, data: { name?: string; slug?: string }) =>