takos-control 1.0.0

package/src/application/services/seed-repositories.ts

@@ -0,0 +1,37 @@
+/**
+ * Seed Repositories
+ *
+ * A flat list of repository URLs shown to users during new account/workspace
+ * creation. The frontend renders these in a selection popup so the user can
+ * pick which ones to clone into their workspace.
+ *
+ * This has nothing to do with the store — the store is for discovery.
+ * This is purely "here are some repos you probably want on day one".
+ */
+
+export interface SeedRepository {
+  /** Clone URL (git HTTPS) */
+  url: string;
+  /** Human-readable name */
+  name: string;
+  /** Short description */
+  description: string;
+  /** Category tag for grouping in the UI */
+  category: string;
+  /** Whether this is pre-checked in the popup */
+  checked: boolean;
+}
+
+/**
+ * The list. Add / remove entries here.
+ * Order matters — it's the display order in the popup.
+ */
+export const SEED_REPOSITORIES: SeedRepository[] = [
+  {
+    url: 'https://github.com/tako0614/takos-computer.git',
+    name: 'Takos Computer',
+    description: 'Browser automation and agent executor',
+    category: 'tool',
+    checked: true,
+  },
+];

package/src/application/services/source/__tests__/app-manifest-template.test.ts

@@ -0,0 +1,211 @@
+import { describe, expect, it } from 'vitest';
+import {
+  resolveTemplates,
+  validateTemplateReferences,
+  type TemplateContext,
+} from '../app-manifest-template';
+
+describe('app-manifest-template', () => {
+  const context: TemplateContext = {
+    routes: {
+      'browser-api': { url: 'https://browser-api.example.com', domain: 'browser-api.example.com', path: '/api' },
+      api: { url: 'https://api.example.com', domain: 'api.example.com', path: '/' },
+    },
+    containers: {
+      executor: { ipv4: '10.0.0.1', port: 8080 },
+      headless: { port: 9222 },
+    },
+    workers: {
+      'browser-host': { url: 'https://browser-host.workers.dev' },
+      api: { url: 'https://api.workers.dev' },
+    },
+    resources: {
+      'mcp-auth-secret': { id: 'secret-abc-123' },
+      db: { id: 'db-xyz-456' },
+    },
+  };
+
+  describe('resolveTemplates', () => {
+    it('resolves routes.xxx.url', () => {
+      const result = resolveTemplates(
+        { API_URL: '{{routes.api.url}}' },
+        context,
+      );
+      expect(result).toEqual({ API_URL: 'https://api.example.com' });
+    });
+
+    it('resolves containers.xxx.ipv4', () => {
+      const result = resolveTemplates(
+        { EXECUTOR_IP: '{{containers.executor.ipv4}}' },
+        context,
+      );
+      expect(result).toEqual({ EXECUTOR_IP: '10.0.0.1' });
+    });
+
+    it('resolves containers.xxx.port', () => {
+      const result = resolveTemplates(
+        { HEADLESS_PORT: '{{containers.headless.port}}' },
+        context,
+      );
+      expect(result).toEqual({ HEADLESS_PORT: '9222' });
+    });
+
+    it('resolves workers.xxx.url', () => {
+      const result = resolveTemplates(
+        { BROWSER_HOST_URL: '{{workers.browser-host.url}}' },
+        context,
+      );
+      expect(result).toEqual({ BROWSER_HOST_URL: 'https://browser-host.workers.dev' });
+    });
+
+    it('resolves resources.xxx.id', () => {
+      const result = resolveTemplates(
+        { AUTH_SECRET_ID: '{{resources.mcp-auth-secret.id}}' },
+        context,
+      );
+      expect(result).toEqual({ AUTH_SECRET_ID: 'secret-abc-123' });
+    });
+
+    it('resolves multiple templates in one value', () => {
+      const result = resolveTemplates(
+        { CONNECTION: '{{containers.executor.ipv4}}:{{containers.executor.port}}' },
+        context,
+      );
+      expect(result).toEqual({ CONNECTION: '10.0.0.1:8080' });
+    });
+
+    it('resolves multiple keys', () => {
+      const result = resolveTemplates(
+        {
+          API_URL: '{{routes.api.url}}',
+          BROWSER_URL: '{{workers.browser-host.url}}',
+          DB_ID: '{{resources.db.id}}',
+        },
+        context,
+      );
+      expect(result).toEqual({
+        API_URL: 'https://api.example.com',
+        BROWSER_URL: 'https://browser-host.workers.dev',
+        DB_ID: 'db-xyz-456',
+      });
+    });
+
+    it('passes through plain strings without templates', () => {
+      const result = resolveTemplates(
+        { STATIC: 'hello-world' },
+        context,
+      );
+      expect(result).toEqual({ STATIC: 'hello-world' });
+    });
+
+    it('throws on unknown template path', () => {
+      expect(() =>
+        resolveTemplates(
+          { BAD: '{{routes.nonexistent.url}}' },
+          context,
+        ),
+      ).toThrow('Template variable not found: {{routes.nonexistent.url}}');
+    });
+
+    it('throws on deeply unknown path', () => {
+      expect(() =>
+        resolveTemplates(
+          { BAD: '{{containers.executor.nonexistent}}' },
+          context,
+        ),
+      ).toThrow('Template variable not found: {{containers.executor.nonexistent}}');
+    });
+
+    it('throws on unknown top-level section', () => {
+      expect(() =>
+        resolveTemplates(
+          { BAD: '{{databases.main.url}}' },
+          context,
+        ),
+      ).toThrow('Template variable not found: {{databases.main.url}}');
+    });
+  });
+
+  describe('validateTemplateReferences', () => {
+    const manifest = {
+      containers: { executor: {}, headless: {} },
+      workers: { 'browser-host': {}, api: {} },
+      routes: [{ name: 'browser-api' }, { name: 'api' }],
+      resources: { 'mcp-auth-secret': {}, db: {} },
+    };
+
+    it('returns no errors for valid references', () => {
+      const errors = validateTemplateReferences(
+        {
+          API_URL: '{{routes.api.url}}',
+          EXECUTOR_IP: '{{containers.executor.ipv4}}',
+          BROWSER_URL: '{{workers.browser-host.url}}',
+          SECRET: '{{resources.mcp-auth-secret.id}}',
+        },
+        manifest,
+      );
+      expect(errors).toEqual([]);
+    });
+
+    it('reports unknown route reference', () => {
+      const errors = validateTemplateReferences(
+        { URL: '{{routes.missing.url}}' },
+        manifest,
+      );
+      expect(errors).toEqual(['URL: route "missing" not found']);
+    });
+
+    it('reports unknown container reference', () => {
+      const errors = validateTemplateReferences(
+        { IP: '{{containers.missing.ipv4}}' },
+        manifest,
+      );
+      expect(errors).toEqual(['IP: container "missing" not found']);
+    });
+
+    it('reports unknown worker reference', () => {
+      const errors = validateTemplateReferences(
+        { URL: '{{workers.missing.url}}' },
+        manifest,
+      );
+      expect(errors).toEqual(['URL: worker "missing" not found']);
+    });
+
+    it('reports unknown resource reference', () => {
+      const errors = validateTemplateReferences(
+        { ID: '{{resources.missing.id}}' },
+        manifest,
+      );
+      expect(errors).toEqual(['ID: resource "missing" not found']);
+    });
+
+    it('reports unknown section', () => {
+      const errors = validateTemplateReferences(
+        { BAD: '{{databases.main.url}}' },
+        manifest,
+      );
+      expect(errors).toEqual(['BAD: unknown section "databases"']);
+    });
+
+    it('reports invalid short path', () => {
+      const errors = validateTemplateReferences(
+        { BAD: '{{routes}}' },
+        manifest,
+      );
+      expect(errors).toEqual(['BAD: invalid template path "routes"']);
+    });
+
+    it('collects multiple errors', () => {
+      const errors = validateTemplateReferences(
+        {
+          A: '{{routes.nope.url}}',
+          B: '{{containers.nope.port}}',
+        },
+        manifest,
+      );
+      expect(errors).toHaveLength(2);
+      expect(errors[0]).toContain('route "nope" not found');
+      expect(errors[1]).toContain('container "nope" not found');
+    });
+  });
+});

package/src/application/services/source/app-manifest-bundle.ts

@@ -0,0 +1,427 @@
+import YAML from 'yaml';
+import { computeSHA256 } from '../../../shared/utils/hash';
+import { safeJsonParseOrDefault } from '../../../shared/utils';
+import {
+  normalizeRepoPath,
+  BUILD_SOURCE_LABELS,
+  type AppManifest,
+  type AppDeploymentBuildSource,
+  type BundleDoc,
+} from './app-manifest-types';
+
+function buildSourceLabels(source: AppDeploymentBuildSource): Record<string, string> {
+  return {
+    [BUILD_SOURCE_LABELS.workflowPath]: source.workflow_path,
+    [BUILD_SOURCE_LABELS.workflowJob]: source.workflow_job,
+    [BUILD_SOURCE_LABELS.workflowArtifact]: source.workflow_artifact,
+    [BUILD_SOURCE_LABELS.artifactPath]: source.artifact_path,
+    ...(source.workflow_run_id ? { [BUILD_SOURCE_LABELS.sourceRunId]: source.workflow_run_id } : {}),
+    ...(source.workflow_job_id ? { [BUILD_SOURCE_LABELS.sourceJobId]: source.workflow_job_id } : {}),
+    ...(source.source_sha ? { [BUILD_SOURCE_LABELS.sourceSha]: source.source_sha } : {}),
+  };
+}
+
+// ── New format types (inline until types merge) ──────────────────────────────
+
+/** Container definition in the new `spec.containers` section */
+interface ManifestContainer {
+  dockerfile: string;
+  port?: number;
+  instanceType?: string;
+  maxInstances?: number;
+  ipv4?: boolean;
+  env?: Record<string, string>;
+}
+
+/** Worker definition in the new `spec.workers` section */
+interface ManifestWorker {
+  build: {
+    fromWorkflow: {
+      path: string;
+      job: string;
+      artifact: string;
+      artifactPath: string;
+    };
+  };
+  env?: Record<string, string>;
+  bindings?: {
+    d1?: string[];
+    r2?: string[];
+    kv?: string[];
+    vectorize?: string[];
+    queues?: string[];
+    analytics?: string[];
+    workflows?: string[];
+    durableObjects?: string[];
+    services?: string[];
+  };
+  triggers?: {
+    schedules?: Array<{ cron: string; export: string }>;
+    queues?: Array<{ queue: string; export: string }>;
+  };
+  containers?: string[];
+}
+
+interface ManifestRoute {
+  name?: string;
+  target: string;
+  path?: string;
+  ingress?: string;
+  timeoutMs?: number;
+}
+
+// ── New-format bundle generation ─────────────────────────────────────────────
+
+function emitNewFormatDocs(
+  manifest: AppManifest,
+  buildSources: Map<string, AppDeploymentBuildSource>,
+  docs: BundleDoc[],
+): void {
+  const spec = manifest.spec as unknown as Record<string, unknown>;
+  const containers = (spec.containers || {}) as Record<string, ManifestContainer>;
+  const workers = (spec.workers || {}) as Record<string, ManifestWorker>;
+  const routes = (spec.routes || []) as ManifestRoute[];
+
+  // Track which containers are referenced by workers (non-standalone)
+  const workerReferencedContainers = new Set<string>();
+  for (const worker of Object.values(workers)) {
+    for (const cRef of worker.containers || []) {
+      workerReferencedContainers.add(cRef);
+    }
+  }
+
+  // ── Standalone containers ──────────────────────────────────────────────────
+  for (const [containerName, container] of Object.entries(containers)) {
+    if (workerReferencedContainers.has(containerName)) continue;
+    docs.push({
+      apiVersion: 'takos.dev/v1alpha1',
+      kind: 'Workload',
+      metadata: { name: containerName },
+      spec: {
+        type: 'container',
+        pluginConfig: {
+          dockerfile: container.dockerfile,
+          ...(container.port != null ? { port: container.port } : {}),
+          ...(container.instanceType ? { instanceType: container.instanceType } : {}),
+          ...(container.maxInstances ? { maxInstances: container.maxInstances } : {}),
+          ...(container.ipv4 ? { ipv4: true } : {}),
+        },
+        ...(container.env ? { env: container.env } : {}),
+      },
+    });
+  }
+
+  // ── Workers ────────────────────────────────────────────────────────────────
+  for (const [workerName, worker] of Object.entries(workers)) {
+    const source = buildSources.get(workerName);
+    if (!source) {
+      throw new Error(`Build source is missing for worker: ${workerName}`);
+    }
+
+    // Resolve container references from the containers section
+    const resolvedContainers = (worker.containers || []).map((cRef) => {
+      const cDef = containers[cRef];
+      if (!cDef) {
+        throw new Error(`Worker '${workerName}' references unknown container '${cRef}'`);
+      }
+      return { name: cRef, ...cDef };
+    });
+
+    docs.push({
+      apiVersion: 'takos.dev/v1alpha1',
+      kind: 'Workload',
+      metadata: {
+        name: workerName,
+        labels: buildSourceLabels(source),
+      },
+      spec: {
+        type: 'cloudflare.worker',
+        artifactRef: source.artifact_path,
+        pluginConfig: {
+          env: worker.env || {},
+          bindings: {
+            services: worker.bindings?.services || [],
+          },
+          ...(worker.triggers ? { triggers: worker.triggers } : {}),
+          ...(resolvedContainers.length > 0
+            ? {
+                containers: resolvedContainers.map((c) => ({
+                  name: c.name,
+                  dockerfile: c.dockerfile,
+                  port: c.port,
+                  ...(c.instanceType ? { instanceType: c.instanceType } : {}),
+                  ...(c.maxInstances ? { maxInstances: c.maxInstances } : {}),
+                })),
+              }
+            : {}),
+        },
+      },
+    });
+
+    // Emit child container Workload + Binding for each container attached to this worker
+    for (const c of resolvedContainers) {
+      docs.push({
+        apiVersion: 'takos.dev/v1alpha1',
+        kind: 'Workload',
+        metadata: { name: `${workerName}-${c.name}` },
+        spec: {
+          type: 'container',
+          parentRef: workerName,
+          pluginConfig: {
+            dockerfile: c.dockerfile,
+            port: c.port,
+            ...(c.instanceType ? { instanceType: c.instanceType } : {}),
+            ...(c.maxInstances ? { maxInstances: c.maxInstances } : {}),
+          },
+        },
+      });
+
+      docs.push({
+        apiVersion: 'takos.dev/v1alpha1',
+        kind: 'Binding',
+        metadata: { name: `${c.name}-container-to-${workerName}` },
+        spec: {
+          from: `${workerName}-${c.name}`,
+          to: workerName,
+          mount: {
+            as: `${c.name.toUpperCase().replace(/-/g, '_')}_CONTAINER`,
+            type: 'durableObject',
+          },
+        },
+      });
+    }
+  }
+
+  // ── Resource bindings (new format: iterate workers) ────────────────────────
+  const resources = manifest.spec.resources || {};
+  for (const [resourceName, resource] of Object.entries(resources)) {
+    if (!resource.binding) continue;
+    for (const [workerName, worker] of Object.entries(workers)) {
+      const bindingLists = worker.bindings || {};
+      const mountType = resource.type === 'secretRef' ? undefined : resource.type;
+      const inBindings = [
+        ...(bindingLists.d1 || []),
+        ...(bindingLists.r2 || []),
+        ...(bindingLists.kv || []),
+        ...(bindingLists.vectorize || []),
+        ...(bindingLists.queues || []),
+        ...(bindingLists.analytics || []),
+        ...(bindingLists.workflows || []),
+        ...(bindingLists.durableObjects || []),
+      ];
+      if (!inBindings.includes(resourceName) || !mountType) continue;
+      docs.push({
+        apiVersion: 'takos.dev/v1alpha1',
+        kind: 'Binding',
+        metadata: { name: `${resourceName}-to-${workerName}` },
+        spec: {
+          from: resourceName,
+          to: workerName,
+          mount: {
+            as: resource.binding,
+            type: mountType,
+          },
+        },
+      });
+    }
+  }
+
+  // ── Routes ─────────────────────────────────────────────────────────────────
+  for (const [index, route] of routes.entries()) {
+    const targetRef = route.target;
+    docs.push({
+      apiVersion: 'takos.dev/v1alpha1',
+      kind: 'Endpoint',
+      metadata: { name: route.name || `route-${index + 1}` },
+      spec: {
+        protocol: 'http',
+        targetRef,
+        ...(route.ingress ? { ingressRef: route.ingress } : {}),
+        ...(route.path ? { path: route.path } : {}),
+        ...(route.timeoutMs != null ? { timeoutMs: route.timeoutMs } : {}),
+      },
+    });
+  }
+}
+
+// ── Public entry point ───────────────────────────────────────────────────────
+
+export function appManifestToBundleDocs(
+  manifest: AppManifest,
+  buildSources: Map<string, AppDeploymentBuildSource>,
+): BundleDoc[] {
+  const docs: BundleDoc[] = [];
+
+  // Package doc
+  const envSpec: Record<string, unknown> = {};
+  if (manifest.spec.env) {
+    if ((manifest.spec.env as Record<string, unknown>).required) {
+      envSpec.required = (manifest.spec.env as Record<string, unknown>).required;
+    }
+    if ((manifest.spec.env as Record<string, unknown>).inject) {
+      envSpec.inject = (manifest.spec.env as Record<string, unknown>).inject;
+    }
+  }
+  docs.push({
+    apiVersion: 'takos.dev/v1alpha1',
+    kind: 'Package',
+    metadata: { name: manifest.metadata.name },
+    spec: {
+      ...(manifest.metadata.appId ? { appId: manifest.metadata.appId } : {}),
+      version: manifest.spec.version,
+      ...(manifest.spec.description ? { description: manifest.spec.description } : {}),
+      ...(manifest.spec.icon ? { icon: manifest.spec.icon } : {}),
+      ...(manifest.spec.category ? { category: manifest.spec.category } : {}),
+      ...(manifest.spec.tags ? { tags: manifest.spec.tags } : {}),
+      ...(manifest.spec.capabilities ? { capabilities: manifest.spec.capabilities } : {}),
+      ...(Object.keys(envSpec).length > 0 ? { env: envSpec } : manifest.spec.env ? { env: manifest.spec.env } : {}),
+      ...(manifest.spec.oauth ? { oauth: manifest.spec.oauth } : {}),
+      ...(manifest.spec.takos ? { takos: manifest.spec.takos } : {}),
+      ...(manifest.spec.fileHandlers ? { fileHandlers: manifest.spec.fileHandlers } : {}),
+    },
+  });
+
+  // Resources (shared between old and new format)
+  for (const [resourceName, resource] of Object.entries(manifest.spec.resources || {})) {
+    docs.push({
+      apiVersion: 'takos.dev/v1alpha1',
+      kind: 'Resource',
+      metadata: { name: resourceName },
+      spec: {
+        type: resource.type,
+        ...(resource.binding ? { binding: resource.binding } : {}),
+        ...(resource.generate ? { generate: resource.generate } : {}),
+        ...(resource.type === 'vectorize' && resource.vectorize ? { vectorize: resource.vectorize } : {}),
+        ...(resource.type === 'queue' && resource.queue ? { queue: resource.queue } : {}),
+        ...(resource.type === 'analyticsEngine' && resource.analyticsEngine ? { analyticsEngine: resource.analyticsEngine } : {}),
+        ...(resource.type === 'workflow' && resource.workflow ? { workflow: resource.workflow } : {}),
+        ...(resource.type === 'durableObject' && resource.durableObject ? { durableObject: resource.durableObject } : {}),
+        ...(resource.migrations
+          ? typeof resource.migrations === 'string'
+            ? { migrations: resource.migrations }
+            : { migrations: resource.migrations.up, rollbackMigrations: resource.migrations.down }
+          : {}),
+      },
+    });
+  }
+
+  emitNewFormatDocs(manifest, buildSources, docs);
+
+  // MCP servers (shared)
+  for (const server of manifest.spec.mcpServers || []) {
+    docs.push({
+      apiVersion: 'takos.dev/v1alpha1',
+      kind: 'McpServer',
+      metadata: { name: server.name },
+      spec: {
+        endpointRef: server.endpoint || server.route,
+        name: server.name,
+        transport: server.transport || 'streamable-http',
+        ...(server.authSecretRef ? { authSecretRef: server.authSecretRef } : {}),
+      },
+    });
+  }
+
+  return docs;
+}
+
+function toManifestDocYaml(doc: BundleDoc): string {
+  return YAML.stringify(doc).trimEnd();
+}
+
+function toUint8Array(content: ArrayBuffer | Uint8Array | string): Uint8Array {
+  if (typeof content === 'string') {
+    return new TextEncoder().encode(content);
+  }
+  if (content instanceof Uint8Array) {
+    return content;
+  }
+  return new Uint8Array(content);
+}
+
+export async function buildBundlePackageData(
+  docs: BundleDoc[],
+  files: Map<string, ArrayBuffer | Uint8Array | string>,
+): Promise<ArrayBuffer> {
+  const manifestYaml = `${docs.map(toManifestDocYaml).join('\n---\n')}\n`;
+  const entries = new Map<string, Uint8Array>();
+  entries.set('manifest.yaml', new TextEncoder().encode(manifestYaml));
+
+  for (const [filePathRaw, content] of files.entries()) {
+    const filePath = normalizeRepoPath(filePathRaw);
+    if (!filePath) continue;
+    entries.set(filePath, toUint8Array(content));
+  }
+
+  const checksums: string[] = [];
+  for (const [filePath, content] of entries.entries()) {
+    checksums.push(`${await computeSHA256(content)} ${filePath}`);
+  }
+  entries.set('checksums.txt', new TextEncoder().encode(`${checksums.sort().join('\n')}\n`));
+
+  const jszip = await import('jszip');
+  const JSZip = 'default' in jszip ? jszip.default : jszip;
+  const zip = new JSZip();
+  for (const [filePath, content] of entries.entries()) {
+    zip.file(filePath, content);
+  }
+  return zip.generateAsync({ type: 'arraybuffer' });
+}
+
+export async function buildParsedPackageFromDocs(
+  docs: BundleDoc[],
+  files: Map<string, ArrayBuffer | Uint8Array | string>,
+): Promise<{ manifestYaml: string; normalizedFiles: Map<string, ArrayBuffer>; checksums: Map<string, string> }> {
+  const manifestYaml = `${docs.map(toManifestDocYaml).join('\n---\n')}\n`;
+  const normalizedFiles = new Map<string, ArrayBuffer>();
+  normalizedFiles.set('manifest.yaml', new TextEncoder().encode(manifestYaml).buffer as ArrayBuffer);
+
+  for (const [filePathRaw, content] of files.entries()) {
+    const filePath = normalizeRepoPath(filePathRaw);
+    if (!filePath) continue;
+    const bytes = toUint8Array(content);
+    normalizedFiles.set(filePath, bytes.buffer as ArrayBuffer);
+  }
+
+  const checksums = new Map<string, string>();
+  for (const [filePath, content] of normalizedFiles.entries()) {
+    checksums.set(filePath, await computeSHA256(new Uint8Array(content)));
+  }
+
+  return { manifestYaml, normalizedFiles, checksums };
+}
+
+export function extractBuildSourcesFromManifestJson(manifestJson: string | null | undefined): AppDeploymentBuildSource[] {
+  const manifest = safeJsonParseOrDefault<{ objects?: Array<{ kind?: string; metadata?: { name?: string; labels?: Record<string, string> } }> } | null>(manifestJson, null);
+  const objects = Array.isArray(manifest?.objects) ? manifest.objects : [];
+  return objects
+    .filter((item) => item.kind === 'Workload')
+    .map((item) => {
+      const labels = item.metadata?.labels || {};
+      const workflowPath = labels[BUILD_SOURCE_LABELS.workflowPath];
+      const workflowJob = labels[BUILD_SOURCE_LABELS.workflowJob];
+      const workflowArtifact = labels[BUILD_SOURCE_LABELS.workflowArtifact];
+      const artifactPath = labels[BUILD_SOURCE_LABELS.artifactPath];
+      if (!workflowPath || !workflowJob || !workflowArtifact || !artifactPath || !item.metadata?.name) {
+        return null;
+      }
+      return {
+        service_name: item.metadata.name,
+        workflow_path: workflowPath,
+        workflow_job: workflowJob,
+        workflow_artifact: workflowArtifact,
+        artifact_path: artifactPath,
+        ...(labels[BUILD_SOURCE_LABELS.sourceRunId] ? { workflow_run_id: labels[BUILD_SOURCE_LABELS.sourceRunId] } : {}),
+        ...(labels[BUILD_SOURCE_LABELS.sourceJobId] ? { workflow_job_id: labels[BUILD_SOURCE_LABELS.sourceJobId] } : {}),
+        ...(labels[BUILD_SOURCE_LABELS.sourceSha] ? { source_sha: labels[BUILD_SOURCE_LABELS.sourceSha] } : {}),
+      } satisfies AppDeploymentBuildSource;
+    })
+    .filter((item): item is AppDeploymentBuildSource => item != null)
+    .sort((left, right) => left.service_name.localeCompare(right.service_name));
+}
+
+export function selectAppManifestPathFromRepo(entries: ReadonlyArray<string>): string | null {
+  if (entries.includes('.takos/app.yml')) return '.takos/app.yml';
+  if (entries.includes('.takos/app.yaml')) return '.takos/app.yaml';
+  return null;
+}