assistant-ui 0.0.125 → 0.0.127

package/src/commands/cloud.ts

@@ -1,12 +1,6 @@
 import { Command, Option } from "commander";
 import * as p from "@clack/prompts";
-import {
-  createProject,
-  fetchOrganizations,
-  fetchProjects,
-  type AccountsOrganization,
-  type AccountsProject,
-} from "aui-auth/accounts";
+import { fetchOrganizations, fetchProjects } from "aui-auth/accounts";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -15,11 +9,13 @@ import {
   cloudAuthConfig,
   loginToCloud,
   logoutFromCloud,
+  openBrowser,
   savedCloudAccessToken,
   validateCloudUrl,
 } from "../lib/cloud-auth";
-import { runCloudCommand } from "../lib/cloud-remote";
+import { runCloudCommand, sendCloudCommand } from "../lib/cloud-remote";
 import {
+  findCloudProjectDefaults,
   readCloudProjectConfig,
   mergeCloudEnvironment,
   readOptionalFile,
@@ -94,6 +90,44 @@ const selectResource = async <
   return resources.find((resource) => resource.id === id)!;
 };
 
+type SetupResource = { id: string; slug: string; name: string };
+
+/**
+ * Runs a Cloud command for setup and returns its `--json` output, so setup
+ * creates organizations and projects with the same checks and audit rows as
+ * `assistant-ui cloud orgs create` and `projects create`.
+ */
+const cloudJson = async <T>(
+  apiUrl: string,
+  token: string,
+  args: string[],
+): Promise<{ ok: true; value: T } | { ok: false; message: string }> => {
+  const response = await sendCloudCommand(apiUrl, [...args, "--json"], token);
+  if (response.exitCode !== 0)
+    return {
+      ok: false,
+      message: (response.stderr ?? "").trim() || `${args.join(" ")} failed.`,
+    };
+  let value: unknown;
+  try {
+    value = JSON.parse(response.stdout ?? "");
+  } catch {
+    value = null;
+  }
+  const resource = value as Partial<SetupResource> | null;
+  if (
+    !resource ||
+    !(["id", "slug", "name"] as const).every(
+      (key) => typeof resource[key] === "string" && resource[key].trim() !== "",
+    )
+  )
+    return {
+      ok: false,
+      message: `Unexpected response from \`${args.join(" ")} --json\`. Update assistant-ui and try again.`,
+    };
+  return { ok: true, value: value as T };
+};
+
 const projectSlug = (value: string): string =>
   value
     .toLowerCase()
@@ -104,7 +138,7 @@ const organizationForSetup = async (
   issuer: string,
   token: string,
   options: SetupOptions,
-): Promise<AccountsOrganization> => {
+): Promise<SetupResource> => {
   const organizations = await fetchOrganizations({ issuer }, token);
   if (!options.newOrg) {
     const existing = await selectResource(
@@ -136,28 +170,25 @@ const organizationForSetup = async (
     (organization) => organization.slug === slug,
   );
   if (existing) return existing;
-  const response = await fetch(`${issuer}/api/oidc/organizations`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ name: options.name ?? slug, slug }),
-    signal: AbortSignal.timeout(30_000),
-    redirect: "error",
-  });
-  if (!response.ok)
-    throw new Error(`Could not create organization (${response.status}).`);
-  return (await response.json()) as AccountsOrganization;
+  const created = await cloudJson<SetupResource>(options.apiUrl, token, [
+    "orgs",
+    "create",
+    slug,
+    "--name",
+    options.name ?? slug,
+  ]);
+  if (!created.ok)
+    throw new Error(`Could not create organization: ${created.message}`);
+  return created.value;
 };
 
 const projectForSetup = async (
   issuer: string,
   token: string,
-  organization: AccountsOrganization,
+  organization: SetupResource,
   directory: string,
   options: SetupOptions,
-): Promise<AccountsProject> => {
+): Promise<SetupResource> => {
   const projects = await fetchProjects({ issuer }, token, {
     id: organization.id,
   });
@@ -173,23 +204,25 @@ const projectForSetup = async (
   const slug = options.newProject ?? projectSlug(path.basename(directory));
   if (!slug)
     throw new Error("Choose a project slug with --new-project <slug>.");
-  const created = await createProject(
-    { issuer },
-    token,
-    { id: organization.id },
-    {
-      name: options.name ?? path.basename(directory),
-      slug,
-    },
-  );
-  if ("reason" in created) {
-    const existing = projects.find((project) => project.slug === slug);
-    if (existing) return existing;
-    throw new Error(
-      `Project slug "${slug}" already exists. Select it with --project or choose another slug.`,
-    );
+  const existing = projects.find((project) => project.slug === slug);
+  if (existing) return existing;
+  const created = await cloudJson<SetupResource>(options.apiUrl, token, [
+    "projects",
+    "create",
+    slug,
+    "--name",
+    options.name ?? path.basename(directory),
+    "--org",
+    organization.id,
+  ]);
+  if (!created.ok) {
+    if (/already exists/.test(created.message))
+      throw new Error(
+        `Project slug "${slug}" already exists. Select it with --project or choose another slug.`,
+      );
+    throw new Error(`Could not create project: ${created.message}`);
   }
-  return created;
+  return created.value;
 };
 
 const scaffoldCloudProject = async (
@@ -379,13 +412,32 @@ export const cloud = new Command()
   .description("manage Assistant Cloud (run `assistant-ui cloud help`)")
   .helpOption(false)
   .helpCommand(false)
+  // `cloud login --no-open` is login's own flag; `cloud <remote> --no-open`
+  // is this one; Commander forwards tokens after `--` without the separator.
+  .enablePositionalOptions()
+  .option("--no-open", "print dashboard links without opening a browser")
   .argument("[command...]")
   .allowUnknownOption()
   .allowExcessArguments()
-  .action(async (args: string[]) => {
+  .action(async (args: string[], options: { open?: boolean }) => {
+    // The server's help knows the local commands only by name; their flags
+    // live here, so `help <local command>` is answered on this machine.
+    const local =
+      args[0] === "help" && args.length === 2
+        ? cloud.commands.find((command) => command.name() === args[1])
+        : undefined;
+    if (local) {
+      process.stdout.write(local.helpInformation());
+      return;
+    }
     process.exitCode = await runCloudCommand(args, {
       cloudUrl: process.env.ASSISTANT_UI_CLOUD_URL ?? DEFAULT_CLOUD_URL,
       accessToken: () => savedCloudAccessToken(cloudAuthConfig()),
+      defaults: () => findCloudProjectDefaults(process.cwd()),
+      interactive:
+        !!process.stdin.isTTY && !!process.stderr.isTTY && !process.env.CI,
+      noOpen: options.open === false,
+      openUrl: openBrowser,
       stdout: (text) => process.stdout.write(text),
       stderr: (text) => process.stderr.write(text),
     });

package/src/commands/mcp.test.ts

@@ -0,0 +1,123 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { mcp } from "./mcp";
+
+const directories: string[] = [];
+afterEach(() => {
+  for (const directory of directories.splice(0)) {
+    fs.rmSync(directory, { recursive: true, force: true });
+  }
+  vi.restoreAllMocks();
+});
+
+const fixture = () => {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "assistant-ui-mcp-"));
+  directories.push(directory);
+  vi.spyOn(process, "cwd").mockReturnValue(directory);
+  vi.spyOn(console, "log").mockImplementation(() => {});
+  vi.spyOn(console, "error").mockImplementation(() => {});
+  vi.spyOn(process, "exit").mockImplementation(() => {
+    throw new Error("exit");
+  });
+  return directory;
+};
+
+describe("mcp project configuration", () => {
+  it.each([
+    [
+      "--cursor",
+      ".cursor",
+      "mcpServers",
+      { url: "https://www.assistant-ui.com/mcp" },
+    ],
+    [
+      "--vscode",
+      ".vscode",
+      "servers",
+      { type: "http", url: "https://www.assistant-ui.com/mcp" },
+    ],
+  ])(
+    "writes %s configuration through a linked directory",
+    async (flag, name, key, server) => {
+      const directory = fixture();
+      const shared = fs.mkdtempSync(
+        path.join(os.tmpdir(), "assistant-ui-mcp-shared-"),
+      );
+      directories.push(shared);
+      fs.symlinkSync(shared, path.join(directory, name), "dir");
+      await mcp.parseAsync([flag], { from: "user" });
+      expect(
+        JSON.parse(fs.readFileSync(path.join(shared, "mcp.json"), "utf8")),
+      ).toEqual({
+        [key]: { "assistant-ui": server },
+      });
+    },
+  );
+
+  it("writes regular and missing project configuration files", async () => {
+    const directory = fixture();
+    await mcp.parseAsync(["--cursor"], { from: "user" });
+    const file = path.join(directory, ".cursor", "mcp.json");
+    expect(JSON.parse(fs.readFileSync(file, "utf8"))).toEqual({
+      mcpServers: {
+        "assistant-ui": { url: "https://www.assistant-ui.com/mcp" },
+      },
+    });
+    fs.writeFileSync(file, '{"other":true}\n');
+    await mcp.parseAsync(["--cursor"], { from: "user" });
+    expect(JSON.parse(fs.readFileSync(file, "utf8"))).toEqual({
+      other: true,
+      mcpServers: {
+        "assistant-ui": { url: "https://www.assistant-ui.com/mcp" },
+      },
+    });
+  });
+
+  it("writes a home configuration through its existing directory link", async () => {
+    fixture();
+    const home = fs.mkdtempSync(
+      path.join(os.tmpdir(), "assistant-ui-mcp-home-"),
+    );
+    const configDir = fs.mkdtempSync(
+      path.join(os.tmpdir(), "assistant-ui-mcp-config-"),
+    );
+    directories.push(home, configDir);
+    vi.spyOn(os, "homedir").mockReturnValue(home);
+    fs.symlinkSync(configDir, path.join(home, ".codeium"), "dir");
+    fs.mkdirSync(path.join(configDir, "windsurf"));
+    await mcp.parseAsync(["--windsurf"], { from: "user" });
+    const file = path.join(configDir, "windsurf", "mcp_config.json");
+    expect(JSON.parse(fs.readFileSync(file, "utf8"))).toEqual({
+      mcpServers: {
+        "assistant-ui": { serverUrl: "https://www.assistant-ui.com/mcp" },
+      },
+    });
+  });
+
+  it("writes a linked home configuration file through its link", async () => {
+    fixture();
+    const home = fs.mkdtempSync(
+      path.join(os.tmpdir(), "assistant-ui-mcp-home-"),
+    );
+    const dotfiles = fs.mkdtempSync(
+      path.join(os.tmpdir(), "assistant-ui-mcp-dotfiles-"),
+    );
+    directories.push(home, dotfiles);
+    vi.spyOn(os, "homedir").mockReturnValue(home);
+    const target = path.join(dotfiles, "mcp_config.json");
+    fs.writeFileSync(target, '{"other":true}\n');
+    fs.mkdirSync(path.join(home, ".codeium", "windsurf"), { recursive: true });
+    const file = path.join(home, ".codeium", "windsurf", "mcp_config.json");
+    fs.symlinkSync(target, file);
+    await mcp.parseAsync(["--windsurf"], { from: "user" });
+    expect(fs.lstatSync(file).isSymbolicLink()).toBe(true);
+    expect(JSON.parse(fs.readFileSync(target, "utf8"))).toEqual({
+      other: true,
+      mcpServers: {
+        "assistant-ui": { serverUrl: "https://www.assistant-ui.com/mcp" },
+      },
+    });
+  });
+});

package/src/lib/agent-skill.ts

@@ -5,7 +5,7 @@ import { withStagedDownload } from "./utils/download";
 import { dlxCommand, type PackageManagerName } from "./utils/package-manager";
 
 export const SKILLS_PACKAGE = "assistant-ui/skills";
-export const SKILLS_COMMIT = "1ba8e9105c504fe4ac2591e432783872d6b3c8ba";
+export const SKILLS_COMMIT = "b0609e66baff7e19f21053d5492464dcc22ec9c3";
 export const SKILLS_PLUGIN_SOURCE = `gh:${SKILLS_PACKAGE}/assistant-ui#${SKILLS_COMMIT}`;
 
 export function resolveSkillsInstall(params: {

package/src/lib/cloud-auth.ts

@@ -133,7 +133,7 @@ export const saveCloudCredentials = async (
   }
 };
 
-const openBrowser = (url: string): void => {
+export const openBrowser = (url: string): void => {
   const command =
     process.platform === "darwin"
       ? "open"

package/src/lib/cloud-config.test.ts

@@ -1,14 +1,114 @@
-import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import {
+  chmod,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  stat,
+  symlink,
+  writeFile,
+} from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { describe, expect, it } from "vitest";
 import {
+  findCloudProjectDefaults,
   mergeCloudEnvironment,
   readCloudProjectConfig,
+  writeCloudFile,
   writeCloudProjectConfig,
+  type CloudProjectConfig,
 } from "./cloud-config";
 
 describe("cloud environment", () => {
+  const tempDir = async () => {
+    const directory = await mkdtemp(
+      path.join(os.tmpdir(), "assistant-ui-cloud-"),
+    );
+    return directory;
+  };
+
+  it("refuses a symbolic link and preserves its target", async () => {
+    const directory = await tempDir();
+    try {
+      const target = path.join(directory, "target");
+      const file = path.join(directory, ".env.local");
+      await writeFile(target, "original\n");
+      await chmod(target, 0o644);
+      await symlink(target, file);
+      await expect(
+        writeCloudFile(file, "replacement\n", { projectRoot: directory }),
+      ).rejects.toThrow(`${file} is a symbolic link`);
+      expect(await readFile(target, "utf8")).toBe("original\n");
+      expect((await stat(target)).mode & 0o777).toBe(0o644);
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+    }
+  });
+
+  it("refuses a parent directory linked outside the project", async () => {
+    const directory = await tempDir();
+    const outside = await tempDir();
+    try {
+      await symlink(outside, path.join(directory, ".assistant-ui"), "dir");
+      await expect(
+        writeCloudFile(
+          path.join(directory, ".assistant-ui", "cloud.json"),
+          "secret",
+          { projectRoot: directory },
+        ),
+      ).rejects.toThrow("outside the project");
+      await expect(
+        readFile(path.join(outside, "cloud.json"), "utf8"),
+      ).rejects.toMatchObject({ code: "ENOENT" });
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+      await rm(outside, { recursive: true, force: true });
+    }
+  });
+
+  it("writes regular and missing files", async () => {
+    const directory = await tempDir();
+    try {
+      const file = path.join(directory, ".assistant-ui", "cloud.json");
+      await mkdir(path.dirname(file));
+      await writeCloudFile(file, "first\n", { projectRoot: directory });
+      await writeCloudFile(file, "second\n", { projectRoot: directory });
+      expect(await readFile(file, "utf8")).toBe("second\n");
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+    }
+  });
+
+  it("refuses a linked environment file before reading cloud configuration", async () => {
+    const directory = await tempDir();
+    try {
+      const target = path.join(directory, "target");
+      const file = path.join(directory, ".env.local");
+      await writeFile(target, "ORIGINAL=1\n");
+      await chmod(target, 0o644);
+      await symlink(target, file);
+      const config: CloudProjectConfig = {
+        organizationId: "org",
+        organizationSlug: "team",
+        projectId: "project",
+        projectSlug: "chat",
+        harnessId: "harness",
+        harnessOrigin: "https://harness.example.com",
+        apiOrigin: "https://project.example.com",
+        workspaceId: "workspace",
+        backendUrl: "http://localhost:3000/api/chat",
+      };
+      await expect(
+        writeCloudProjectConfig(directory, config, "private-key"),
+      ).rejects.toThrow(`${file} is a symbolic link`);
+      expect(await readFile(target, "utf8")).toBe("ORIGINAL=1\n");
+      expect((await stat(target)).mode & 0o777).toBe(0o644);
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+    }
+  });
+
   it("preserves custom settings and repeated configuration", () => {
     const original = "# My settings\nOPENAI_API_KEY=my-existing-key\n";
     const merged = mergeCloudEnvironment(original, {
@@ -79,4 +179,42 @@ describe("cloud environment", () => {
       await rm(directory, { recursive: true, force: true });
     }
   });
+
+  it("finds the nearest cloud.json's org and project for remote commands", async () => {
+    const root = await tempDir();
+    try {
+      const nested = path.join(root, "app", "src", "deep");
+      await mkdir(nested, { recursive: true });
+      await mkdir(path.join(root, "app", ".assistant-ui"));
+      await writeFile(
+        path.join(root, "app", ".assistant-ui", "cloud.json"),
+        JSON.stringify({ organizationId: "org_1", projectId: "proj_1" }),
+      );
+      await mkdir(path.join(root, ".assistant-ui"));
+      await writeFile(
+        path.join(root, ".assistant-ui", "cloud.json"),
+        JSON.stringify({
+          organizationId: "org_outer",
+          projectId: "proj_outer",
+        }),
+      );
+      await expect(findCloudProjectDefaults(nested)).resolves.toEqual({
+        org: "org_1",
+        project: "proj_1",
+      });
+      await expect(findCloudProjectDefaults(root)).resolves.toEqual({
+        org: "org_outer",
+        project: "proj_outer",
+      });
+      await rm(path.join(root, ".assistant-ui"), { recursive: true });
+      await expect(findCloudProjectDefaults(root)).resolves.toBeNull();
+      await writeFile(
+        path.join(root, "app", ".assistant-ui", "cloud.json"),
+        "{not json",
+      );
+      await expect(findCloudProjectDefaults(nested)).resolves.toBeNull();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
 });

package/src/lib/cloud-config.ts

@@ -1,14 +1,16 @@
 import {
   mkdir,
+  open,
   readFile,
-  writeFile,
   link,
   rename,
   rm,
   stat,
 } from "node:fs/promises";
+import { constants } from "node:fs";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
+import { assertSafeProjectFile } from "./safe-project-file";
 
 export type CloudProjectConfig = {
   organizationId: string;
@@ -25,15 +27,28 @@ export type CloudProjectConfig = {
 export const writeCloudFile = async (
   file: string,
   contents: string,
-  options: { exclusive?: boolean; mode?: number } = {},
+  options: { exclusive?: boolean; mode?: number; projectRoot: string },
 ): Promise<void> => {
+  const { projectRoot } = options;
+  assertSafeProjectFile(file, projectRoot);
   await mkdir(path.dirname(file), { recursive: true });
+  assertSafeProjectFile(file, projectRoot);
   const temporary = `${file}.${randomUUID()}.tmp`;
   try {
-    await writeFile(temporary, contents, {
-      flag: "wx",
-      mode: options.mode ?? 0o600,
-    });
+    const handle = await open(
+      temporary,
+      constants.O_WRONLY |
+        constants.O_CREAT |
+        constants.O_EXCL |
+        constants.O_NOFOLLOW,
+      options.mode ?? 0o600,
+    );
+    try {
+      await handle.writeFile(contents);
+    } finally {
+      await handle.close();
+    }
+    assertSafeProjectFile(file, projectRoot);
     if (options.exclusive) await link(temporary, file);
     else await rename(temporary, file);
   } finally {
@@ -57,6 +72,37 @@ export const readCloudProjectConfig = async (
   }
 };
 
+/**
+ * The org and project `setup` configured for this directory or the nearest
+ * parent with an `.assistant-ui/cloud.json`, for remote commands to use when
+ * no --org or --project is given. A missing or unreadable file means none.
+ */
+export const findCloudProjectDefaults = async (
+  directory: string,
+): Promise<{ org?: string; project?: string } | null> => {
+  for (let current = path.resolve(directory); ;) {
+    try {
+      const config = JSON.parse(
+        await readFile(cloudProjectConfigPath(current), "utf8"),
+      ) as Partial<CloudProjectConfig> | null;
+      const org =
+        typeof config?.organizationId === "string"
+          ? config.organizationId
+          : undefined;
+      const project =
+        typeof config?.projectId === "string" ? config.projectId : undefined;
+      return org || project
+        ? { ...(org && { org }), ...(project && { project }) }
+        : null;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") return null;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+};
+
 export const readOptionalFile = async (file: string): Promise<string> => {
   try {
     return await readFile(file, "utf8");
@@ -106,6 +152,10 @@ export const writeCloudProjectConfig = async (
   apiKey: string,
 ): Promise<void> => {
   const envFile = path.join(directory, ".env.local");
+  const gitignoreFile = path.join(directory, ".gitignore");
+  assertSafeProjectFile(envFile, directory);
+  assertSafeProjectFile(gitignoreFile, directory);
+  assertSafeProjectFile(cloudProjectConfigPath(directory), directory);
   const contents = await readOptionalFile(envFile);
   const environment = mergeCloudEnvironment(contents, {
     ASSISTANT_API_KEY: apiKey,
@@ -113,7 +163,6 @@ export const writeCloudProjectConfig = async (
     NEXT_PUBLIC_ASSISTANT_HARNESS_URL: config.harnessOrigin,
     NEXT_PUBLIC_ASSISTANT_WORKSPACE_ID: config.workspaceId,
   });
-  const gitignoreFile = path.join(directory, ".gitignore");
   const gitignore = await readOptionalFile(gitignoreFile);
   const ignored = gitignore.split(/\r?\n/).map((line) => line.trim());
   if (!ignored.includes(".env.local") && !ignored.includes(".env*.local")) {
@@ -121,6 +170,7 @@ export const writeCloudProjectConfig = async (
       gitignoreFile,
       `${gitignore}${gitignore && !gitignore.endsWith("\n") ? "\n" : ""}.env.local\n`,
       {
+        projectRoot: directory,
         mode: await stat(gitignoreFile)
           .then((info) => info.mode & 0o777)
           .catch((error: NodeJS.ErrnoException) => {
@@ -130,9 +180,10 @@ export const writeCloudProjectConfig = async (
       },
     );
   }
-  await writeCloudFile(envFile, environment);
+  await writeCloudFile(envFile, environment, { projectRoot: directory });
   await writeCloudFile(
     cloudProjectConfigPath(directory),
     `${JSON.stringify(config, null, 2)}\n`,
+    { projectRoot: directory },
   );
 };

package/src/lib/cloud-provision.test.ts

@@ -1,4 +1,13 @@
-import { mkdtemp, readFile, rm } from "node:fs/promises";
+import {
+  chmod,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  stat,
+  symlink,
+  writeFile,
+} from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
@@ -32,6 +41,22 @@ const input = {
 };
 
 describe("cloud provisioning", () => {
+  it("refuses a linked pending request without changing its target", async () => {
+    const dir = await directory();
+    const configDir = path.join(dir, ".assistant-ui");
+    await mkdir(configDir);
+    const target = path.join(dir, "target.json");
+    const file = path.join(configDir, "provision.json");
+    await writeFile(target, "original\n");
+    await chmod(target, 0o644);
+    await symlink(target, file);
+    await expect(resolveProvisionRequest(dir, input)).rejects.toThrow(
+      `${file} is a symbolic link`,
+    );
+    expect(await readFile(target, "utf8")).toBe("original\n");
+    expect((await stat(target)).mode & 0o777).toBe(0o644);
+  });
+
   it("replays the same identity after a failed request without persisting an access code", async () => {
     const dir = await directory();
     const first = await resolveProvisionRequest(

package/src/lib/cloud-provision.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { readOptionalFile, writeCloudFile } from "./cloud-config";
+import { assertSafeProjectFile } from "./safe-project-file";
 import { validateCloudUrl } from "./cloud-auth";
 
 export type CloudProvisionRequest = {
@@ -28,6 +29,7 @@ export const resolveProvisionRequest = async (
   accessCode?: string,
 ): Promise<CloudProvisionRequest> => {
   const file = path.join(directory, ".assistant-ui", "provision.json");
+  assertSafeProjectFile(file, directory);
   const previous = await readOptionalFile(file);
   let request: CloudProvisionRequest;
   if (previous) {
@@ -42,6 +44,7 @@ export const resolveProvisionRequest = async (
     request = { ...input, idempotency_key: randomUUID() };
     await writeCloudFile(file, `${JSON.stringify(request, null, 2)}\n`, {
       exclusive: true,
+      projectRoot: directory,
     });
   }
   return { ...request, ...(accessCode ? { access_code: accessCode } : {}) };