takos-control 1.0.0

package/src/application/services/offload/run-events.ts

@@ -0,0 +1,128 @@
+import type { R2Bucket } from '../../../shared/types/bindings.ts';
+import { gzipCompressString, gzipDecompressToString } from '../../../shared/utils/gzip';
+
+export interface PersistedRunEvent {
+  event_id: number;
+  type: string;
+  data: string; // JSON string
+  created_at: string;
+}
+
+export const RUN_EVENT_SEGMENT_SIZE = 100;
+
+function pad6(n: number): string {
+  return String(n).padStart(6, '0');
+}
+
+export function segmentIndexForEventId(eventId: number): number {
+  if (!Number.isFinite(eventId) || eventId <= 0) return 1;
+  return Math.floor((eventId - 1) / RUN_EVENT_SEGMENT_SIZE) + 1;
+}
+
+export function buildRunEventSegmentKey(runId: string, segmentIndex: number): string {
+  return `runs/${runId}/events/${pad6(segmentIndex)}.jsonl.gz`;
+}
+
+export async function writeRunEventSegmentToR2(
+  bucket: R2Bucket,
+  runId: string,
+  segmentIndex: number,
+  events: PersistedRunEvent[],
+): Promise<void> {
+  const key = buildRunEventSegmentKey(runId, segmentIndex);
+  const jsonl = events.map((e) => JSON.stringify(e)).join('\n') + '\n';
+  const compressed = await gzipCompressString(jsonl);
+  await bucket.put(key, compressed, {
+    httpMetadata: {
+      contentType: 'application/x-ndjson; charset=utf-8',
+      contentEncoding: 'gzip',
+    },
+  });
+}
+
+function parseSegmentIndexFromKey(key: string, prefix: string): number | null {
+  if (!key.startsWith(prefix)) return null;
+  const rest = key.slice(prefix.length);
+  const m = rest.match(/^(\d+)\.jsonl\.gz$/);
+  if (!m) return null;
+  const n = Number(m[1]);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  return Math.floor(n);
+}
+
+export async function listRunEventSegmentIndexes(bucket: R2Bucket, runId: string): Promise<number[]> {
+  const prefix = `runs/${runId}/events/`;
+  const indexes = new Set<number>();
+
+  let cursor: string | undefined;
+  while (true) {
+    const res = await bucket.list({ prefix, cursor });
+    for (const obj of res.objects) {
+      const idx = parseSegmentIndexFromKey(obj.key, prefix);
+      if (idx) indexes.add(idx);
+    }
+    if (res.truncated) {
+      cursor = res.cursor;
+      continue;
+    }
+    break;
+  }
+
+  return Array.from(indexes).sort((a, b) => a - b);
+}
+
+export async function readRunEventSegmentFromR2(
+  bucket: R2Bucket,
+  runId: string,
+  segmentIndex: number,
+): Promise<PersistedRunEvent[] | null> {
+  const key = buildRunEventSegmentKey(runId, segmentIndex);
+  const obj = await bucket.get(key);
+  if (!obj) return null;
+  const compressed = await obj.arrayBuffer();
+  const jsonl = await gzipDecompressToString(compressed, { maxDecompressedBytes: 200 * 1024 * 1024 });
+
+  const events: PersistedRunEvent[] = [];
+  for (const line of jsonl.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed) as PersistedRunEvent;
+      if (!parsed || typeof parsed !== 'object') continue;
+      if (typeof parsed.event_id !== 'number' || !Number.isFinite(parsed.event_id)) continue;
+      if (typeof parsed.type !== 'string') continue;
+      if (typeof parsed.data !== 'string') continue;
+      if (typeof parsed.created_at !== 'string') continue;
+      events.push(parsed);
+    } catch (_err) { /* ignored - skip malformed lines */ }
+  }
+
+  events.sort((a, b) => a.event_id - b.event_id);
+  return events;
+}
+
+export async function getRunEventsAfterFromR2(
+  bucket: R2Bucket,
+  runId: string,
+  afterEventId: number,
+  limit: number = 500,
+): Promise<PersistedRunEvent[]> {
+  const startSegment = Math.floor(Math.max(0, afterEventId) / RUN_EVENT_SEGMENT_SIZE) + 1;
+  const segmentIndexes = (await listRunEventSegmentIndexes(bucket, runId)).filter((n) => n >= startSegment);
+
+  const segments = await Promise.all(
+    segmentIndexes.map((idx) => readRunEventSegmentFromR2(bucket, runId, idx)),
+  );
+
+  const out: PersistedRunEvent[] = [];
+  for (const segment of segments) {
+    if (!segment) continue;
+    for (const e of segment) {
+      if (e.event_id <= afterEventId) continue;
+      out.push(e);
+      if (out.length >= limit) return out;
+    }
+  }
+
+  return out;
+}

package/src/application/services/offload/usage-client.ts

@@ -0,0 +1,39 @@
+import type { Env } from '../../../shared/types';
+import type { DurableObjectStubBinding } from '../../../shared/types/bindings.ts';
+import { buildDurableObjectUrl } from '../../../shared/utils';
+
+type RunNotifierNamespace = {
+  idFromName(name: string): unknown;
+  get(id: unknown): DurableObjectStubBinding;
+};
+
+export async function emitRunUsageEvent(
+  env: Env,
+  input: {
+    runId: string;
+    meterType: string;
+    units: number;
+    referenceType?: string;
+    metadata?: unknown;
+  }
+): Promise<void> {
+  if (!env.TAKOS_OFFLOAD) return;
+  const ns = env.RUN_NOTIFIER as unknown as RunNotifierNamespace;
+  if (!ns) return;
+  if (!input.runId) return;
+
+  const id = ns.idFromName(input.runId);
+  const stub = ns.get(id) as DurableObjectStubBinding;
+  const request = new Request(buildDurableObjectUrl('/usage'), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-Takos-Internal': '1' },
+    body: JSON.stringify({
+      runId: input.runId,
+      meter_type: input.meterType,
+      units: input.units,
+      reference_type: input.referenceType,
+      metadata: input.metadata,
+    }),
+  });
+  await stub.fetch(request);
+}

package/src/application/services/offload/usage-events.ts

@@ -0,0 +1,100 @@
+import type { R2Bucket, R2ObjectBody } from '../../../shared/types/bindings.ts';
+import { gzipCompressString, gzipDecompressToString } from '../../../shared/utils/gzip';
+
+export type PersistedUsageEvent = {
+  meter_type: string;
+  units: number;
+  reference_type?: string | null;
+  metadata?: string | null;
+  created_at: string;
+};
+
+export const USAGE_EVENT_SEGMENT_SIZE = 200;
+const USAGE_PREFIX_SUFFIX = '/usage/';
+
+export function usageSegmentKey(runId: string, segmentIndex: number): string {
+  return `runs/${runId}/usage/${String(segmentIndex).padStart(6, '0')}.jsonl.gz`;
+}
+
+export async function writeUsageEventSegmentToR2(
+  bucket: R2Bucket,
+  runId: string,
+  segmentIndex: number,
+  events: PersistedUsageEvent[]
+): Promise<void> {
+  if (!events.length) return;
+  const jsonl = events.map((e) => JSON.stringify(e)).join('\n') + '\n';
+  const gz = await gzipCompressString(jsonl);
+  const key = usageSegmentKey(runId, segmentIndex);
+  await bucket.put(key, gz, {
+    httpMetadata: {
+      contentType: 'application/jsonl',
+      contentEncoding: 'gzip',
+    },
+    customMetadata: {
+      kind: 'usage_events',
+      run_id: runId,
+      segment: String(segmentIndex),
+    },
+  });
+}
+
+async function listUsageSegments(bucket: R2Bucket, runId: string): Promise<string[]> {
+  const prefix = `runs/${runId}${USAGE_PREFIX_SUFFIX}`;
+  const keys: string[] = [];
+  let cursor: string | undefined;
+
+  while (true) {
+    const listed = await bucket.list({ prefix, cursor, limit: 1000 });
+    for (const obj of listed.objects) {
+      keys.push(obj.key);
+    }
+    if (!listed.truncated) break;
+    cursor = listed.cursor;
+  }
+
+  keys.sort();
+  return keys;
+}
+
+async function readSegmentObject(obj: R2ObjectBody): Promise<PersistedUsageEvent[]> {
+  const ab = await obj.arrayBuffer();
+  const jsonl = await gzipDecompressToString(ab, { maxDecompressedBytes: 50 * 1024 * 1024 });
+  const lines = jsonl.split('\n').filter(Boolean);
+  const out: PersistedUsageEvent[] = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line) as PersistedUsageEvent;
+      if (!parsed || typeof parsed !== 'object') continue;
+      if (typeof parsed.meter_type !== 'string') continue;
+      if (typeof parsed.units !== 'number' || !Number.isFinite(parsed.units)) continue;
+      if (typeof parsed.created_at !== 'string') continue;
+      out.push(parsed);
+    } catch (_err) { /* ignored - skip malformed lines */ }
+  }
+  return out;
+}
+
+export async function getUsageEventsFromR2(
+  bucket: R2Bucket,
+  runId: string,
+  options: { maxEvents?: number } = {}
+): Promise<PersistedUsageEvent[]> {
+  const maxEvents = Math.max(1, Math.min(options.maxEvents ?? 10_000, 100_000));
+  const keys = await listUsageSegments(bucket, runId);
+  const objects = await Promise.all(keys.map((key) => bucket.get(key)));
+  const segments = await Promise.all(
+    objects.map((obj) => (obj ? readSegmentObject(obj) : Promise.resolve([] as PersistedUsageEvent[]))),
+  );
+
+  const out: PersistedUsageEvent[] = [];
+  for (const events of segments) {
+    for (const ev of events) {
+      out.push(ev);
+      if (out.length >= maxEvents) return out;
+    }
+  }
+
+  return out;
+}
+

package/src/application/services/platform/app-deployments.ts

@@ -0,0 +1,397 @@
+import { getDb } from '../../../infra/db';
+import { workflowRuns, workflowJobs } from '../../../infra/db/schema';
+import { eq, and, desc } from 'drizzle-orm';
+import type { Env } from '../../../shared/types';
+import { checkRepoAccess } from '../source/repos';
+import * as gitStore from '../git-smart';
+import { resolveWorkflowArtifactFileForJob } from './workflow-artifacts';
+import {
+  appManifestToBundleDocs,
+  buildParsedPackageFromDocs,
+  extractBuildSourcesFromManifestJson,
+  parseAndValidateWorkflowYaml,
+  parseAppManifestYaml,
+  selectAppManifestPathFromRepo,
+  validateDeployProducerJob,
+  type AppDeploymentBuildSource,
+  type AppManifest,
+} from '../source/app-manifest';
+
+type RepoRefType = 'branch' | 'tag' | 'commit';
+
+type CreateAppDeploymentInput = {
+  repoId: string;
+  ref?: string;
+  refType?: RepoRefType;
+  approveOauthAutoEnv?: boolean;
+  approveSourceChange?: boolean;
+};
+
+type ResolvedRepoTarget = {
+  repoId: string;
+  ref: string;
+  refType: RepoRefType;
+  commitSha: string;
+  treeSha: string;
+};
+
+type ResolvedBuildArtifacts = {
+  buildSources: AppDeploymentBuildSource[];
+  packageFiles: Map<string, ArrayBuffer | Uint8Array>;
+};
+
+export function encodeSourceRef(refType: RepoRefType | undefined, ref: string | undefined, commitSha?: string): string | undefined {
+  const normalizedRef = String(ref || '').trim();
+  if (!normalizedRef) return undefined;
+  const base = `${refType || 'branch'}:${normalizedRef}`;
+  return commitSha ? `${base}@${commitSha}` : base;
+}
+
+export function decodeSourceRef(encoded: string | null | undefined): {
+  ref: string | null;
+  ref_type: RepoRefType | null;
+  commit_sha: string | null;
+} {
+  const raw = String(encoded || '').trim();
+  if (!raw) return { ref: null, ref_type: null, commit_sha: null };
+  const separator = raw.indexOf(':');
+  if (separator <= 0) return { ref: raw, ref_type: null, commit_sha: null };
+  const rawType = raw.slice(0, separator).trim();
+  const rest = raw.slice(separator + 1).trim();
+  const atIndex = rest.indexOf('@');
+  const ref = atIndex > 0 ? rest.slice(0, atIndex) : rest;
+  const commitSha = atIndex > 0 ? rest.slice(atIndex + 1) : null;
+  return {
+    ref: ref || null,
+    ref_type: rawType === 'branch' || rawType === 'tag' || rawType === 'commit' ? rawType : null,
+    commit_sha: commitSha || null,
+  };
+}
+
+function normalizeRepoPath(value: string): string {
+  return String(value || '')
+    .replace(/\\/g, '/')
+    .replace(/^\.\/+/, '')
+    .replace(/^\/+/, '')
+    .replace(/\/{2,}/g, '/')
+    .trim();
+}
+
+function getGitBucket(env: Env) {
+  return env.GIT_OBJECTS || null;
+}
+
+
+function buildWorkflowRunRef(refType: RepoRefType, ref: string): string | null {
+  if (refType === 'branch') return `refs/heads/${ref}`;
+  if (refType === 'tag') return `refs/tags/${ref}`;
+  return null;
+}
+
+function normalizeRepoRef(refType: RepoRefType, ref: string): string {
+  const normalized = String(ref || '').trim();
+  if (!normalized) {
+    throw new Error('ref is required');
+  }
+  if (refType === 'branch') {
+    return normalized.replace(/^refs\/heads\//, '');
+  }
+  if (refType === 'tag') {
+    return normalized.replace(/^refs\/tags\//, '');
+  }
+  return normalized;
+}
+
+function isDirectoryMode(mode: string | undefined): boolean {
+  return mode === '040000' || mode === '40000';
+}
+
+function looksLikeInlineSql(value: string): boolean {
+  const sql = value.trim();
+  if (!sql) return false;
+  if (/\n/.test(sql) && /;/.test(sql)) return true;
+  return /^(--|\/\*|\s*(create|alter|drop|insert|update|delete|pragma|begin|commit|with)\b)/i.test(sql);
+}
+
+async function readRepoTextFileAtCommit(
+  env: Env,
+  treeSha: string,
+  filePath: string,
+): Promise<string | null> {
+  const bucket = getGitBucket(env);
+  if (!bucket) throw new Error('Git storage is not configured');
+  const blob = await gitStore.getBlobAtPath(bucket, treeSha, normalizeRepoPath(filePath));
+  if (!blob) return null;
+  return new TextDecoder().decode(blob);
+}
+
+function toArrayBuffer(value: ArrayBuffer | SharedArrayBuffer | ArrayBufferView): ArrayBuffer {
+  if (value instanceof ArrayBuffer) return value.slice(0);
+  if (value instanceof SharedArrayBuffer) {
+    const copy = new Uint8Array(value.byteLength);
+    copy.set(new Uint8Array(value));
+    return copy.buffer;
+  }
+  const copy = new Uint8Array(value.byteLength);
+  copy.set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  return copy.buffer;
+}
+
+async function readRepoManifestAtCommit(env: Env, treeSha: string): Promise<{ path: string; raw: string }> {
+  const entries = ['.takos/app.yml', '.takos/app.yaml'] as const;
+  const found: string[] = [];
+  for (const entry of entries) {
+    const content = await readRepoTextFileAtCommit(env, treeSha, entry);
+    if (content != null) {
+      found.push(entry);
+      if (found.length === 1) {
+        return { path: entry, raw: content };
+      }
+    }
+  }
+  const selected = selectAppManifestPathFromRepo(found);
+  if (!selected) {
+    throw new Error('No .takos/app.yml found at the requested repo ref');
+  }
+  throw new Error(`Failed to read manifest: ${selected}`);
+}
+
+async function addRepoSqlPathToPackage(
+  env: Env,
+  treeSha: string,
+  configuredPath: string,
+  packageFiles: Map<string, ArrayBuffer | Uint8Array>,
+): Promise<void> {
+  const bucket = getGitBucket(env);
+  if (!bucket) throw new Error('Git storage is not configured');
+
+  const normalizedPath = normalizeRepoPath(configuredPath);
+  if (!normalizedPath) {
+    throw new Error('Migration path is empty');
+  }
+
+  const entry = await gitStore.getEntryAtPath(bucket, treeSha, normalizedPath);
+  if (!entry) {
+    throw new Error(`Migration path not found in repo: ${normalizedPath}`);
+  }
+
+  if (isDirectoryMode(entry.mode)) {
+    const files = await gitStore.flattenTree(bucket, entry.sha, normalizedPath, { skipSymlinks: true });
+    const sqlFiles = files.filter((file) => file.path.toLowerCase().endsWith('.sql'));
+    if (sqlFiles.length === 0) {
+      throw new Error(`Migration directory contains no .sql files: ${normalizedPath}`);
+    }
+    for (const file of sqlFiles) {
+      const blob = await gitStore.getBlob(bucket, file.sha);
+      if (!blob) {
+        throw new Error(`Migration file not found in git object storage: ${file.path}`);
+      }
+      packageFiles.set(file.path, toArrayBuffer(blob));
+    }
+    return;
+  }
+
+  if (!normalizedPath.toLowerCase().endsWith('.sql')) {
+    throw new Error(`Migration file must end with .sql: ${normalizedPath}`);
+  }
+  const blob = await gitStore.getBlob(bucket, entry.sha);
+  if (!blob) {
+    throw new Error(`Migration file not found in git object storage: ${normalizedPath}`);
+  }
+  packageFiles.set(normalizedPath, toArrayBuffer(blob));
+}
+
+export class AppDeploymentService {
+  constructor(private env: Env) {}
+
+  private async resolveRepoTarget(spaceId: string, userId: string, input: CreateAppDeploymentInput): Promise<ResolvedRepoTarget> {
+    const repoId = String(input.repoId || '').trim();
+    if (!repoId) throw new Error('repo_id is required');
+
+    const repoAccess = await checkRepoAccess(this.env, repoId, userId, ['owner', 'admin', 'editor']);
+    if (!repoAccess || repoAccess.spaceId !== spaceId) {
+      throw new Error('Repository not found or not accessible from this space');
+    }
+
+    const refType = input.refType || 'branch';
+    const ref = normalizeRepoRef(
+      refType,
+      String(input.ref || '').trim() || (refType === 'branch' ? repoAccess.repo.default_branch || 'main' : ''),
+    );
+    if (!ref) {
+      throw new Error('ref is required for tag/commit deployments');
+    }
+
+    const bucket = getGitBucket(this.env);
+    if (!bucket) throw new Error('Git storage is not configured');
+
+    const commitSha = refType === 'commit'
+      ? ref
+      : await gitStore.resolveRef(this.env.DB, repoId, ref);
+    if (!commitSha) {
+      throw new Error(`Ref not found: ${ref}`);
+    }
+    const commit = await gitStore.getCommitData(bucket, commitSha);
+    if (!commit) {
+      throw new Error(`Commit not found: ${commitSha}`);
+    }
+
+    return {
+      repoId,
+      ref,
+      refType,
+      commitSha,
+      treeSha: commit.tree,
+    };
+  }
+
+  private async resolveBuildArtifacts(
+    target: ResolvedRepoTarget,
+    manifest: AppManifest,
+  ): Promise<ResolvedBuildArtifacts> {
+    const bucket = getGitBucket(this.env);
+    if (!bucket) throw new Error('Git storage is not configured');
+    const db = getDb(this.env.DB);
+    const workflowCache = new Map<string, ReturnType<typeof parseAndValidateWorkflowYaml>>();
+    const packageFiles = new Map<string, ArrayBuffer | Uint8Array>();
+    const buildSources: AppDeploymentBuildSource[] = [];
+
+    for (const [workerName, worker] of Object.entries(manifest.spec.workers || {})) {
+      const build = worker.build.fromWorkflow;
+      const workflowContent = await readRepoTextFileAtCommit(this.env, target.treeSha, build.path);
+      if (!workflowContent) {
+        throw new Error(`Workflow file not found at repo ref: ${build.path}`);
+      }
+
+      let workflow = workflowCache.get(build.path);
+      if (!workflow) {
+        workflow = parseAndValidateWorkflowYaml(workflowContent, build.path);
+        workflowCache.set(build.path, workflow);
+      }
+      validateDeployProducerJob(workflow, build.path, build.job);
+
+      const workflowRunRef = buildWorkflowRunRef(target.refType, target.ref);
+
+      // Build where conditions for workflow run query
+      const baseConditions = and(
+        eq(workflowRuns.repoId, target.repoId),
+        eq(workflowRuns.workflowPath, build.path),
+        eq(workflowRuns.status, 'completed'),
+        eq(workflowRuns.conclusion, 'success'),
+        ...(workflowRunRef ? [eq(workflowRuns.ref, workflowRunRef)] : [eq(workflowRuns.sha, target.commitSha)]),
+      );
+
+      // Find matching workflow runs
+      const matchingRuns = await db.select({
+        id: workflowRuns.id,
+        sha: workflowRuns.sha,
+        completedAt: workflowRuns.completedAt,
+        createdAt: workflowRuns.createdAt,
+      }).from(workflowRuns).where(baseConditions).orderBy(
+        desc(workflowRuns.completedAt),
+        desc(workflowRuns.createdAt),
+      ).all();
+
+      // Find a run with a successful matching job
+      let foundRun: { id: string; sha: string | null; jobId: string } | null = null;
+      for (const run of matchingRuns) {
+        const matchingJob = await db.select({ id: workflowJobs.id }).from(workflowJobs).where(
+          and(
+            eq(workflowJobs.runId, run.id),
+            eq(workflowJobs.jobKey, build.job),
+            eq(workflowJobs.status, 'completed'),
+            eq(workflowJobs.conclusion, 'success'),
+          )
+        ).orderBy(
+          desc(workflowJobs.completedAt),
+          desc(workflowJobs.createdAt),
+        ).get();
+
+        if (matchingJob) {
+          foundRun = { id: run.id, sha: run.sha, jobId: matchingJob.id };
+          break;
+        }
+      }
+
+      if (!foundRun) {
+        throw new Error(`Latest successful workflow run not found for ${build.path}#${build.job} on ${target.refType}:${target.ref}`);
+      }
+
+      const jobId = String(foundRun.jobId || '').trim();
+      if (!jobId) {
+        throw new Error(`Successful workflow job record not found for ${build.path}#${build.job} on run ${foundRun.id}`);
+      }
+
+      const artifactPath = normalizeRepoPath(build.artifactPath);
+      const resolvedArtifact = await resolveWorkflowArtifactFileForJob(this.env, {
+        repoId: target.repoId,
+        runId: foundRun.id,
+        jobId,
+        artifactName: build.artifact,
+        artifactPath,
+      });
+      const artifactObject = await bucket.get(resolvedArtifact.r2Key)
+        || await this.env.TENANT_SOURCE?.get(resolvedArtifact.r2Key)
+        || null;
+      if (!artifactObject) {
+        throw new Error(`Workflow artifact file disappeared during app deploy: ${resolvedArtifact.r2Key}`);
+      }
+
+      packageFiles.set(artifactPath, new Uint8Array(await artifactObject.arrayBuffer()));
+      buildSources.push({
+        service_name: workerName,
+        workflow_path: build.path,
+        workflow_job: build.job,
+        workflow_artifact: build.artifact,
+        artifact_path: artifactPath,
+        workflow_run_id: foundRun.id,
+        workflow_job_id: jobId,
+        ...(foundRun.sha ? { source_sha: foundRun.sha } : {}),
+      });
+    }
+
+    for (const resource of Object.values(manifest.spec.resources || {})) {
+      if (!resource.migrations) continue;
+      if (typeof resource.migrations === 'string') {
+        if (!looksLikeInlineSql(resource.migrations)) {
+          await addRepoSqlPathToPackage(this.env, target.treeSha, resource.migrations, packageFiles);
+        }
+        continue;
+      }
+
+      await addRepoSqlPathToPackage(this.env, target.treeSha, resource.migrations.up, packageFiles);
+      await addRepoSqlPathToPackage(this.env, target.treeSha, resource.migrations.down, packageFiles);
+    }
+
+    return {
+      buildSources,
+      packageFiles,
+    };
+  }
+
+  async deployFromRepoRef(_spaceId: string, _userId: string, _input: CreateAppDeploymentInput): Promise<never> {
+    throw new Error('Legacy bundle deployment pipeline has been removed. Use the app deployment API instead.');
+  }
+
+  async list(_spaceId: string): Promise<never> {
+    throw new Error('Legacy bundle deployment pipeline has been removed. Use the app deployment API instead.');
+  }
+
+  async get(_spaceId: string, _appDeploymentId: string): Promise<never> {
+    throw new Error('Legacy bundle deployment pipeline has been removed. Use the app deployment API instead.');
+  }
+
+  async remove(_spaceId: string, _appDeploymentId: string): Promise<never> {
+    throw new Error('Legacy bundle deployment pipeline has been removed. Use the app deployment API instead.');
+  }
+
+  async rollback(_spaceId: string, _userId: string, _appDeploymentId: string, _options?: {
+    approveOauthAutoEnv?: boolean;
+  }): Promise<never> {
+    throw new Error('Legacy bundle deployment pipeline has been removed. Use the app deployment API instead.');
+  }
+}
+
+export function createAppDeploymentService(env: Env) {
+  return new AppDeploymentService(env);
+}