tower-studio 0.1.2 → 0.1.3

package/public/vs/wgsl-BhLXMOR0.js

@@ -0,0 +1,298 @@
+define("vs/wgsl-BhLXMOR0",["exports"],(function(a){"use strict";const s={comments:{lineComment:"//",blockComment:["/*","*/"]},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"[",close:"]"},{open:"{",close:"}"},{open:"(",close:")"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"}]};function e(b){let i=[];const o=b.split(/\t+|\r+|\n+| +/);for(let r=0;r<o.length;++r)o[r].length>0&&i.push(o[r]);return i}const c=e("true false"),m=e(`
+			  alias
+			  break
+			  case
+			  const
+			  const_assert
+			  continue
+			  continuing
+			  default
+			  diagnostic
+			  discard
+			  else
+			  enable
+			  fn
+			  for
+			  if
+			  let
+			  loop
+			  override
+			  requires
+			  return
+			  struct
+			  switch
+			  var
+			  while
+			  `),l=e(`
+			  NULL
+			  Self
+			  abstract
+			  active
+			  alignas
+			  alignof
+			  as
+			  asm
+			  asm_fragment
+			  async
+			  attribute
+			  auto
+			  await
+			  become
+			  binding_array
+			  cast
+			  catch
+			  class
+			  co_await
+			  co_return
+			  co_yield
+			  coherent
+			  column_major
+			  common
+			  compile
+			  compile_fragment
+			  concept
+			  const_cast
+			  consteval
+			  constexpr
+			  constinit
+			  crate
+			  debugger
+			  decltype
+			  delete
+			  demote
+			  demote_to_helper
+			  do
+			  dynamic_cast
+			  enum
+			  explicit
+			  export
+			  extends
+			  extern
+			  external
+			  fallthrough
+			  filter
+			  final
+			  finally
+			  friend
+			  from
+			  fxgroup
+			  get
+			  goto
+			  groupshared
+			  highp
+			  impl
+			  implements
+			  import
+			  inline
+			  instanceof
+			  interface
+			  layout
+			  lowp
+			  macro
+			  macro_rules
+			  match
+			  mediump
+			  meta
+			  mod
+			  module
+			  move
+			  mut
+			  mutable
+			  namespace
+			  new
+			  nil
+			  noexcept
+			  noinline
+			  nointerpolation
+			  noperspective
+			  null
+			  nullptr
+			  of
+			  operator
+			  package
+			  packoffset
+			  partition
+			  pass
+			  patch
+			  pixelfragment
+			  precise
+			  precision
+			  premerge
+			  priv
+			  protected
+			  pub
+			  public
+			  readonly
+			  ref
+			  regardless
+			  register
+			  reinterpret_cast
+			  require
+			  resource
+			  restrict
+			  self
+			  set
+			  shared
+			  sizeof
+			  smooth
+			  snorm
+			  static
+			  static_assert
+			  static_cast
+			  std
+			  subroutine
+			  super
+			  target
+			  template
+			  this
+			  thread_local
+			  throw
+			  trait
+			  try
+			  type
+			  typedef
+			  typeid
+			  typename
+			  typeof
+			  union
+			  unless
+			  unorm
+			  unsafe
+			  unsized
+			  use
+			  using
+			  varying
+			  virtual
+			  volatile
+			  wgsl
+			  where
+			  with
+			  writeonly
+			  yield
+			  `),u=e(`
+		read write read_write
+		function private workgroup uniform storage
+		perspective linear flat
+		center centroid sample
+		vertex_index instance_index position front_facing frag_depth
+			local_invocation_id local_invocation_index
+			global_invocation_id workgroup_id num_workgroups
+			sample_index sample_mask
+		rgba8unorm
+		rgba8snorm
+		rgba8uint
+		rgba8sint
+		rgba16uint
+		rgba16sint
+		rgba16float
+		r32uint
+		r32sint
+		r32float
+		rg32uint
+		rg32sint
+		rg32float
+		rgba32uint
+		rgba32sint
+		rgba32float
+		bgra8unorm
+`),p=e(`
+		bool
+		f16
+		f32
+		i32
+		sampler sampler_comparison
+		texture_depth_2d
+		texture_depth_2d_array
+		texture_depth_cube
+		texture_depth_cube_array
+		texture_depth_multisampled_2d
+		texture_external
+		texture_external
+		u32
+		`),d=e(`
+		array
+		atomic
+		mat2x2
+		mat2x3
+		mat2x4
+		mat3x2
+		mat3x3
+		mat3x4
+		mat4x2
+		mat4x3
+		mat4x4
+		ptr
+		texture_1d
+		texture_2d
+		texture_2d_array
+		texture_3d
+		texture_cube
+		texture_cube_array
+		texture_multisampled_2d
+		texture_storage_1d
+		texture_storage_2d
+		texture_storage_2d_array
+		texture_storage_3d
+		vec2
+		vec3
+		vec4
+		`),x=e(`
+		vec2i vec3i vec4i
+		vec2u vec3u vec4u
+		vec2f vec3f vec4f
+		vec2h vec3h vec4h
+		mat2x2f mat2x3f mat2x4f
+		mat3x2f mat3x3f mat3x4f
+		mat4x2f mat4x3f mat4x4f
+		mat2x2h mat2x3h mat2x4h
+		mat3x2h mat3x3h mat3x4h
+		mat4x2h mat4x3h mat4x4h
+		`),f=e(`
+  bitcast all any select arrayLength abs acos acosh asin asinh atan atanh atan2
+  ceil clamp cos cosh countLeadingZeros countOneBits countTrailingZeros cross
+  degrees determinant distance dot exp exp2 extractBits faceForward firstLeadingBit
+  firstTrailingBit floor fma fract frexp inverseBits inverseSqrt ldexp length
+  log log2 max min mix modf normalize pow quantizeToF16 radians reflect refract
+  reverseBits round saturate sign sin sinh smoothstep sqrt step tan tanh transpose
+  trunc dpdx dpdxCoarse dpdxFine dpdy dpdyCoarse dpdyFine fwidth fwidthCoarse fwidthFine
+  textureDimensions textureGather textureGatherCompare textureLoad textureNumLayers
+  textureNumLevels textureNumSamples textureSample textureSampleBias textureSampleCompare
+  textureSampleCompareLevel textureSampleGrad textureSampleLevel textureSampleBaseClampToEdge
+  textureStore atomicLoad atomicStore atomicAdd atomicSub atomicMax atomicMin
+  atomicAnd atomicOr atomicXor atomicExchange atomicCompareExchangeWeak pack4x8snorm
+  pack4x8unorm pack2x16snorm pack2x16unorm pack2x16float unpack4x8snorm unpack4x8unorm
+  unpack2x16snorm unpack2x16unorm unpack2x16float storageBarrier workgroupBarrier
+  workgroupUniformLoad
+`),_=e(`
+					 &
+					 &&
+					 ->
+					 /
+					 =
+					 ==
+					 !=
+					 >
+					 >=
+					 <
+					 <=
+					 %
+					 -
+					 --
+					 +
+					 ++
+					 |
+					 ||
+					 *
+					 <<
+					 >>
+					 +=
+					 -=
+					 *=
+					 /=
+					 %=
+					 &=
+					 |=
+					 ^=
+					 >>=
+					 <<=
+					 `),g=/enable|requires|diagnostic/,n=new RegExp("[_\\p{XID_Start}]\\p{XID_Continue}*","u"),t="variable.predefined",h={tokenPostfix:".wgsl",defaultToken:"invalid",unicode:!0,atoms:c,keywords:m,reserved:l,predeclared_enums:u,predeclared_types:p,predeclared_type_generators:d,predeclared_type_aliases:x,predeclared_intrinsics:f,operators:_,symbols:/[!%&*+\-\.\/:;<=>^|_~,]+/,tokenizer:{root:[[g,"keyword","@directive"],[n,{cases:{"@atoms":t,"@keywords":"keyword","@reserved":"invalid","@predeclared_enums":t,"@predeclared_types":t,"@predeclared_type_generators":t,"@predeclared_type_aliases":t,"@predeclared_intrinsics":t,"@default":"identifier"}}],{include:"@commentOrSpace"},{include:"@numbers"},[/[{}()\[\]]/,"@brackets"],["@","annotation","@attribute"],[/@symbols/,{cases:{"@operators":"operator","@default":"delimiter"}}],[/./,"invalid"]],commentOrSpace:[[/\s+/,"white"],[/\/\*/,"comment","@blockComment"],[/\/\/.*$/,"comment"]],blockComment:[[/[^\/*]+/,"comment"],[/\/\*/,"comment","@push"],[/\*\//,"comment","@pop"],[/[\/*]/,"comment"]],attribute:[{include:"@commentOrSpace"},[/\w+/,"annotation","@pop"]],directive:[{include:"@commentOrSpace"},[/[()]/,"@brackets"],[/,/,"delimiter"],[n,"meta.content"],[/;/,"delimiter","@pop"]],numbers:[[/0[fh]/,"number.float"],[/[1-9][0-9]*[fh]/,"number.float"],[/[0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[fh]?/,"number.float"],[/[0-9]+\.[0-9]*([eE][+-]?[0-9]+)?[fh]?/,"number.float"],[/[0-9]+[eE][+-]?[0-9]+[fh]?/,"number.float"],[/0[xX][0-9a-fA-F]*\.[0-9a-fA-F]+(?:[pP][+-]?[0-9]+[fh]?)?/,"number.hex"],[/0[xX][0-9a-fA-F]+\.[0-9a-fA-F]*(?:[pP][+-]?[0-9]+[fh]?)?/,"number.hex"],[/0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+[fh]?/,"number.hex"],[/0[xX][0-9a-fA-F]+[iu]?/,"number.hex"],[/[1-9][0-9]*[iu]?/,"number"],[/0[iu]?/,"number"]]}};a.conf=s,a.language=h,Object.defineProperty(a,Symbol.toStringTag,{value:"Module"})}));

package/public/vs/workers-DcJshg-q.js

@@ -0,0 +1 @@
+define("vs/workers-DcJshg-q",["exports","./editor.api-CalNCsUg"],(function(c,a){"use strict";function l(e,o){const r=globalThis.MonacoEnvironment;if(r?.createTrustedTypesPolicy)try{return r.createTrustedTypesPolicy(e,o)}catch(t){console.error(t);return}try{return globalThis.trustedTypes?.createPolicy(e,o)}catch(t){console.error(t);return}}let n;typeof self=="object"&&self.constructor&&self.constructor.name==="DedicatedWorkerGlobalScope"&&globalThis.workerttPolicy!==void 0?n=globalThis.workerttPolicy:n=l("defaultWorkerFactory",{createScriptURL:e=>e});function i(e){const o=e.label,r=globalThis.MonacoEnvironment;if(r){if(typeof r.getWorker=="function")return r.getWorker("workerMain.js",o);if(typeof r.getWorkerUrl=="function"){const t=r.getWorkerUrl("workerMain.js",o);return new Worker(n?n.createScriptURL(t):t,{name:o,type:"module"})}}if(e.createWorker)return e.createWorker();throw new Error("You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker")}function s(e){const o=Promise.resolve(i({label:e.label??"monaco-editor-worker",moduleId:e.moduleId,createWorker:e.createWorker})).then(r=>(r.postMessage("ignore"),r.postMessage(e.createData),r));return a.editor.createWebWorker({worker:o,host:e.host,keepIdleModels:e.keepIdleModels})}c.createWebWorker=s}));

package/public/vs/xml-CdsdnY8S.js

@@ -0,0 +1 @@
+define("vs/xml-CdsdnY8S",["exports","./editor.api-CalNCsUg"],(function(e,t){"use strict";const n={comments:{blockComment:["<!--","-->"]},brackets:[["<",">"]],autoClosingPairs:[{open:"<",close:">"},{open:"'",close:"'"},{open:'"',close:'"'}],surroundingPairs:[{open:"<",close:">"},{open:"'",close:"'"},{open:'"',close:'"'}],onEnterRules:[{beforeText:new RegExp("<([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$","i"),afterText:/^<\/([_:\w][_:\w-.\d]*)\s*>$/i,action:{indentAction:t.languages.IndentAction.IndentOutdent}},{beforeText:new RegExp("<(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$","i"),action:{indentAction:t.languages.IndentAction.Indent}}]},a={defaultToken:"",tokenPostfix:".xml",ignoreCase:!0,qualifiedName:/(?:[\w\.\-]+:)?[\w\.\-]+/,tokenizer:{root:[[/[^<&]+/,""],{include:"@whitespace"},[/(<)(@qualifiedName)/,[{token:"delimiter"},{token:"tag",next:"@tag"}]],[/(<\/)(@qualifiedName)(\s*)(>)/,[{token:"delimiter"},{token:"tag"},"",{token:"delimiter"}]],[/(<\?)(@qualifiedName)/,[{token:"delimiter"},{token:"metatag",next:"@tag"}]],[/(<\!)(@qualifiedName)/,[{token:"delimiter"},{token:"metatag",next:"@tag"}]],[/<\!\[CDATA\[/,{token:"delimiter.cdata",next:"@cdata"}],[/&\w+;/,"string.escape"]],cdata:[[/[^\]]+/,""],[/\]\]>/,{token:"delimiter.cdata",next:"@pop"}],[/\]/,""]],tag:[[/[ \t\r\n]+/,""],[/(@qualifiedName)(\s*=\s*)("[^"]*"|'[^']*')/,["attribute.name","","attribute.value"]],[/(@qualifiedName)(\s*=\s*)("[^">?\/]*|'[^'>?\/]*)(?=[\?\/]\>)/,["attribute.name","","attribute.value"]],[/(@qualifiedName)(\s*=\s*)("[^">]*|'[^'>]*)/,["attribute.name","","attribute.value"]],[/@qualifiedName/,"attribute.name"],[/\?>/,{token:"delimiter",next:"@pop"}],[/(\/)(>)/,[{token:"tag"},{token:"delimiter",next:"@pop"}]],[/>/,{token:"delimiter",next:"@pop"}]],whitespace:[[/[ \t\r\n]+/,""],[/<!--/,{token:"comment",next:"@comment"}]],comment:[[/[^<\-]+/,"comment.content"],[/-->/,{token:"comment",next:"@pop"}],[/<!--/,"comment.content.invalid"],[/[<\-]/,"comment.content"]]}};e.conf=n,e.language=a,Object.defineProperty(e,Symbol.toStringTag,{value:"Module"})}));

package/public/vs/yaml-DYGvmE88.js

@@ -0,0 +1 @@
+define("vs/yaml-DYGvmE88",["exports","./editor.api-CalNCsUg"],(function(e,n){"use strict";const t={comments:{lineComment:"#"},brackets:[["{","}"],["[","]"],["(",")"]],autoClosingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],surroundingPairs:[{open:"{",close:"}"},{open:"[",close:"]"},{open:"(",close:")"},{open:'"',close:'"'},{open:"'",close:"'"}],folding:{offSide:!0},onEnterRules:[{beforeText:/:\s*$/,action:{indentAction:n.languages.IndentAction.Indent}}]},o={tokenPostfix:".yaml",brackets:[{token:"delimiter.bracket",open:"{",close:"}"},{token:"delimiter.square",open:"[",close:"]"}],keywords:["true","True","TRUE","false","False","FALSE","null","Null","Null","~"],numberInteger:/(?:0|[+-]?[0-9]+)/,numberFloat:/(?:0|[+-]?[0-9]+)(?:\.[0-9]+)?(?:e[-+][1-9][0-9]*)?/,numberOctal:/0o[0-7]+/,numberHex:/0x[0-9a-fA-F]+/,numberInfinity:/[+-]?\.(?:inf|Inf|INF)/,numberNaN:/\.(?:nan|Nan|NAN)/,numberDate:/\d{4}-\d\d-\d\d([Tt ]\d\d:\d\d:\d\d(\.\d+)?(( ?[+-]\d\d?(:\d\d)?)|Z)?)?/,escapes:/\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,tokenizer:{root:[{include:"@whitespace"},{include:"@comment"},[/%[^ ]+.*$/,"meta.directive"],[/---/,"operators.directivesEnd"],[/\.{3}/,"operators.documentEnd"],[/[-?:](?= )/,"operators"],{include:"@anchor"},{include:"@tagHandle"},{include:"@flowCollections"},{include:"@blockStyle"},[/@numberInteger(?![ \t]*\S+)/,"number"],[/@numberFloat(?![ \t]*\S+)/,"number.float"],[/@numberOctal(?![ \t]*\S+)/,"number.octal"],[/@numberHex(?![ \t]*\S+)/,"number.hex"],[/@numberInfinity(?![ \t]*\S+)/,"number.infinity"],[/@numberNaN(?![ \t]*\S+)/,"number.nan"],[/@numberDate(?![ \t]*\S+)/,"number.date"],[/(".*?"|'.*?'|[^#'"]*?)([ \t]*)(:)( |$)/,["type","white","operators","white"]],{include:"@flowScalars"},[/.+?(?=(\s+#|$))/,{cases:{"@keywords":"keyword","@default":"string"}}]],object:[{include:"@whitespace"},{include:"@comment"},[/\}/,"@brackets","@pop"],[/,/,"delimiter.comma"],[/:(?= )/,"operators"],[/(?:".*?"|'.*?'|[^,\{\[]+?)(?=: )/,"type"],{include:"@flowCollections"},{include:"@flowScalars"},{include:"@tagHandle"},{include:"@anchor"},{include:"@flowNumber"},[/[^\},]+/,{cases:{"@keywords":"keyword","@default":"string"}}]],array:[{include:"@whitespace"},{include:"@comment"},[/\]/,"@brackets","@pop"],[/,/,"delimiter.comma"],{include:"@flowCollections"},{include:"@flowScalars"},{include:"@tagHandle"},{include:"@anchor"},{include:"@flowNumber"},[/[^\],]+/,{cases:{"@keywords":"keyword","@default":"string"}}]],multiString:[[/^( +).+$/,"string","@multiStringContinued.$1"]],multiStringContinued:[[/^( *).+$/,{cases:{"$1==$S2":"string","@default":{token:"@rematch",next:"@popall"}}}]],whitespace:[[/[ \t\r\n]+/,"white"]],comment:[[/#.*$/,"comment"]],flowCollections:[[/\[/,"@brackets","@array"],[/\{/,"@brackets","@object"]],flowScalars:[[/"([^"\\]|\\.)*$/,"string.invalid"],[/'([^'\\]|\\.)*$/,"string.invalid"],[/'[^']*'/,"string"],[/"/,"string","@doubleQuotedString"]],doubleQuotedString:[[/[^\\"]+/,"string"],[/@escapes/,"string.escape"],[/\\./,"string.escape.invalid"],[/"/,"string","@pop"]],blockStyle:[[/[>|][0-9]*[+-]?$/,"operators","@multiString"]],flowNumber:[[/@numberInteger(?=[ \t]*[,\]\}])/,"number"],[/@numberFloat(?=[ \t]*[,\]\}])/,"number.float"],[/@numberOctal(?=[ \t]*[,\]\}])/,"number.octal"],[/@numberHex(?=[ \t]*[,\]\}])/,"number.hex"],[/@numberInfinity(?=[ \t]*[,\]\}])/,"number.infinity"],[/@numberNaN(?=[ \t]*[,\]\}])/,"number.nan"],[/@numberDate(?=[ \t]*[,\]\}])/,"number.date"]],tagHandle:[[/\![^ ]*/,"tag"]],anchor:[[/[&*][^ ]+/,"namespace"]]}};e.conf=t,e.language=o,Object.defineProperty(e,Symbol.toStringTag,{value:"Module"})}));

package/src/actions/__tests__/agent-actions-username.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+
+/**
+ * Mirrors the username injection logic used in startPtyExecution,
+ * resumePtyExecution, and continueLatestPtyExecution in agent-actions.ts.
+ *
+ * This helper is self-contained so tests pass independently of the
+ * full PTY spawn infrastructure.
+ */
+function buildUsernameArgs(username: string | null): string[] {
+  if (!username) return [];
+  return ["--append-system-prompt", `The user's name is ${username}.`];
+}
+
+describe("buildUsernameArgs", () => {
+  it("returns the correct --append-system-prompt args for a valid username", () => {
+    expect(buildUsernameArgs("Alice")).toEqual([
+      "--append-system-prompt",
+      "The user's name is Alice.",
+    ]);
+  });
+
+  it("returns empty array for empty string username", () => {
+    expect(buildUsernameArgs("")).toEqual([]);
+  });
+
+  it("returns empty array for null username", () => {
+    expect(buildUsernameArgs(null)).toEqual([]);
+  });
+});

package/src/actions/__tests__/asset-actions.test.ts

@@ -0,0 +1,251 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    projectAsset: {
+      create: vi.fn(),
+      delete: vi.fn(),
+      findUnique: vi.fn(),
+      findMany: vi.fn(),
+    },
+    project: { findUnique: vi.fn() },
+  },
+}));
+vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
+vi.mock("node:fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:fs")>();
+  return {
+    ...actual,
+    existsSync: vi.fn(() => false),
+    promises: { unlink: vi.fn(), writeFile: vi.fn() },
+    mkdirSync: vi.fn(),
+  };
+});
+vi.mock("@/lib/file-utils", () => ({
+  ensureAssetsDir: vi.fn(() => "/mock/assets/dir"),
+}));
+vi.mock("@/actions/config-actions", () => ({
+  getConfigValue: vi.fn(async () => 52428800), // 50MB default
+}));
+
+import { db } from "@/lib/db";
+import * as fs from "node:fs";
+import { revalidatePath } from "next/cache";
+import { ensureAssetsDir } from "@/lib/file-utils";
+import { getConfigValue } from "@/actions/config-actions";
+import {
+  createAsset,
+  deleteAsset,
+  getProjectAssets,
+  getTaskAssets,
+  getAssetById,
+  uploadAsset,
+} from "@/actions/asset-actions";
+
+const mockDb = db as {
+  projectAsset: {
+    create: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+    findUnique: ReturnType<typeof vi.fn>;
+    findMany: ReturnType<typeof vi.fn>;
+  };
+  project: { findUnique: ReturnType<typeof vi.fn> };
+};
+
+function makeFormData(
+  overrides: { file?: object | null; projectId?: string | null; taskId?: string; description?: string } = {}
+): FormData {
+  const fd = {
+    get: vi.fn((key: string) => {
+      if (key === "file") return "file" in overrides ? overrides.file : makeFile("test.txt", 100);
+      if (key === "projectId") return "projectId" in overrides ? overrides.projectId : "proj123";
+      if (key === "taskId") return overrides.taskId ?? null;
+      if (key === "description") return overrides.description ?? null;
+      return null;
+    }),
+  } as unknown as FormData;
+  return fd;
+}
+
+function makeFile(name: string, size: number, type = "text/plain") {
+  return {
+    name,
+    size,
+    type,
+    arrayBuffer: vi.fn(async () => new ArrayBuffer(size)),
+  };
+}
+
+describe("asset-actions", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // ── createAsset ──────────────────────────────────────────────────────────
+
+  describe("createAsset", () => {
+    it("creates an asset and revalidates path", async () => {
+      const fakeAsset = { id: "a1", filename: "file.txt", path: "/p/file.txt", projectId: "proj123" };
+      mockDb.projectAsset.create.mockResolvedValue(fakeAsset);
+
+      const result = await createAsset({
+        filename: "file.txt",
+        path: "/p/file.txt",
+        projectId: "proj123",
+      });
+
+      expect(mockDb.projectAsset.create).toHaveBeenCalledWith(
+        expect.objectContaining({ data: expect.objectContaining({ filename: "file.txt", projectId: "proj123" }) })
+      );
+      expect(revalidatePath).toHaveBeenCalledWith("/workspaces");
+      expect(result).toBe(fakeAsset);
+    });
+
+    it("throws on empty filename (schema validation)", async () => {
+      await expect(
+        createAsset({ filename: "", path: "/p/file.txt", projectId: "proj123" })
+      ).rejects.toThrow();
+
+      expect(mockDb.projectAsset.create).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── deleteAsset ──────────────────────────────────────────────────────────
+
+  describe("deleteAsset", () => {
+    it("calls unlink when asset has a path, then deletes from DB", async () => {
+      const fakeAsset = { id: "a1", path: "/some/file.txt" };
+      mockDb.projectAsset.findUnique.mockResolvedValue(fakeAsset);
+      (fs.promises.unlink as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+      mockDb.projectAsset.delete.mockResolvedValue(fakeAsset);
+
+      await deleteAsset("a1");
+
+      expect(fs.promises.unlink).toHaveBeenCalledWith("/some/file.txt");
+      expect(mockDb.projectAsset.delete).toHaveBeenCalledWith({ where: { id: "a1" } });
+      expect(revalidatePath).toHaveBeenCalledWith("/workspaces");
+    });
+
+    it("skips unlink when asset path is null, still deletes from DB", async () => {
+      const fakeAsset = { id: "a2", path: null };
+      mockDb.projectAsset.findUnique.mockResolvedValue(fakeAsset);
+      mockDb.projectAsset.delete.mockResolvedValue(fakeAsset);
+
+      await deleteAsset("a2");
+
+      expect(fs.promises.unlink).not.toHaveBeenCalled();
+      expect(mockDb.projectAsset.delete).toHaveBeenCalledWith({ where: { id: "a2" } });
+    });
+  });
+
+  // ── getProjectAssets ─────────────────────────────────────────────────────
+
+  describe("getProjectAssets", () => {
+    it("queries with projectId (includes all assets)", async () => {
+      mockDb.projectAsset.findMany.mockResolvedValue([]);
+
+      await getProjectAssets("proj123");
+
+      expect(mockDb.projectAsset.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { projectId: "proj123" } })
+      );
+    });
+  });
+
+  // ── getTaskAssets ────────────────────────────────────────────────────────
+
+  describe("getTaskAssets", () => {
+    it("queries with taskId filter", async () => {
+      mockDb.projectAsset.findMany.mockResolvedValue([]);
+
+      await getTaskAssets("task456");
+
+      expect(mockDb.projectAsset.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { taskId: "task456" } })
+      );
+    });
+  });
+
+  // ── getAssetById ─────────────────────────────────────────────────────────
+
+  describe("getAssetById", () => {
+    it("calls findUnique with the given assetId", async () => {
+      const fakeAsset = { id: "a1" };
+      mockDb.projectAsset.findUnique.mockResolvedValue(fakeAsset);
+
+      const result = await getAssetById("a1");
+
+      expect(mockDb.projectAsset.findUnique).toHaveBeenCalledWith({ where: { id: "a1" } });
+      expect(result).toBe(fakeAsset);
+    });
+  });
+
+  // ── uploadAsset ──────────────────────────────────────────────────────────
+
+  describe("uploadAsset", () => {
+    it("happy path: writes file and creates asset", async () => {
+      const fakeProject = { id: "proj123" };
+      const fakeAsset = { id: "a1", filename: "test.txt", projectId: "proj123" };
+      mockDb.project.findUnique.mockResolvedValue(fakeProject);
+      mockDb.projectAsset.create.mockResolvedValue(fakeAsset);
+      (fs.promises.writeFile as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+
+      const fd = makeFormData({ file: makeFile("test.txt", 100) });
+      const result = await uploadAsset(fd);
+
+      expect(ensureAssetsDir).toHaveBeenCalledWith("proj123");
+      expect(fs.promises.writeFile).toHaveBeenCalled();
+      expect(mockDb.projectAsset.create).toHaveBeenCalled();
+      expect(result).toBe(fakeAsset);
+    });
+
+    it("throws when file is missing from FormData", async () => {
+      const fd = makeFormData({ file: null });
+
+      await expect(uploadAsset(fd)).rejects.toThrow("Missing file or projectId");
+    });
+
+    it("throws when projectId is missing from FormData", async () => {
+      const fd = makeFormData({ projectId: null });
+
+      await expect(uploadAsset(fd)).rejects.toThrow("Missing file or projectId");
+    });
+
+    it("throws when file is too large", async () => {
+      // getConfigValue returns 100 bytes max
+      (getConfigValue as ReturnType<typeof vi.fn>).mockResolvedValue(100);
+      const largeFile = makeFile("big.bin", 200);
+      const fd = makeFormData({ file: largeFile });
+
+      await expect(uploadAsset(fd)).rejects.toThrow(/File too large/);
+    });
+
+    it("throws when projectId is invalid (not in DB)", async () => {
+      mockDb.project.findUnique.mockResolvedValue(null);
+      const fd = makeFormData({ file: makeFile("test.txt", 10) });
+
+      await expect(uploadAsset(fd)).rejects.toThrow("Invalid projectId");
+    });
+
+    it("sanitizes filename with path traversal attempt", async () => {
+      const fakeProject = { id: "proj123" };
+      const fakeAsset = { id: "a1", filename: "passwd", projectId: "proj123" };
+      mockDb.project.findUnique.mockResolvedValue(fakeProject);
+      mockDb.projectAsset.create.mockResolvedValue(fakeAsset);
+      (fs.promises.writeFile as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+
+      // file named with path traversal: path.basename should strip to "passwd"
+      const traversalFile = makeFile("../../../etc/passwd", 10);
+      const fd = makeFormData({ file: traversalFile });
+
+      const result = await uploadAsset(fd);
+
+      // Verify writeFile was called — the asset was created (not thrown)
+      expect(fs.promises.writeFile).toHaveBeenCalled();
+      // Verify the create call used the sanitized filename (basename only)
+      const createCall = mockDb.projectAsset.create.mock.calls[0][0];
+      expect(createCall.data.filename).toBe("passwd");
+      expect(result).toBe(fakeAsset);
+    });
+  });
+});

package/src/actions/__tests__/assistant-actions.test.ts

@@ -0,0 +1,20 @@
+import { describe, it } from "vitest";
+
+describe("assistant-actions", () => {
+  describe("startAssistantSession", () => {
+    it.todo("creates a PTY session keyed by __assistant__ (BE-01)");
+    it.todo("includes --allowedTools mcp__tower__* in CLI args (BE-03)");
+    it.todo("includes --append-system-prompt with configured prompt (BE-02)");
+    it.todo("destroys existing session before creating new one (UX-01)");
+    it.todo("throws if no default CliProfile exists");
+  });
+
+  describe("stopAssistantSession", () => {
+    it.todo("destroys the __assistant__ session (BE-05)");
+  });
+
+  describe("getAssistantSessionStatus", () => {
+    it.todo("returns 'idle' when no session exists");
+    it.todo("returns 'running' when session is active");
+  });
+});