@cueloop/daemon 0.1.0-alpha.8 → 0.1.0-alpha.80

package/src/validate.ts

@@ -1,5 +1,5 @@
 /**
- * Runtime validation of the wire boundary (#14). Everything arriving over the
+ * Runtime validation of the wire boundary. Everything arriving over the
  * socket is untrusted JSON: adapters, the CLI, extensions, and any script a
  * user writes all speak this protocol. Validating here means DaemonCore only
  * ever sees well-formed input, and a malformed request gets a precise error
@@ -11,17 +11,31 @@
 
 import * as v from "valibot";
 import {
+  ARTIFACT_TYPES,
+  WORKFLOW_KINDS,
   SCHEMA_VERSION,
   type Anchor,
   type Annotation,
+  type AnnotationTarget,
   type Artifact,
   type ArtifactMeta,
-  type ReviewSession,
+  type DiffFileContents,
+  type Identity,
+  type Thread,
+  type HunkRejection,
+  type HarnessBinding,
+  type Delivery,
+  type PendingDelivery,
   type Revision,
-  type Verdict,
+  type SessionHistory,
+  type ShareAccess,
+  type ShareLink,
+  validateHistory,
+  type Message,
   type WorkspaceKey,
 } from "@cueloop/schema";
 import { DaemonError } from "./errors";
+import type { Request } from "./protocol";
 
 /**
  * Drift guard for every hand-mirrored shape below. v.object strips keys it
@@ -37,22 +51,38 @@ const NonEmpty = v.pipe(v.string(), v.minLength(1));
 export const WorkspaceSchema = v.object({
   repoRoot: NonEmpty,
   branch: NonEmpty,
+  rootCommit: v.optional(NonEmpty),
+  remote: v.optional(NonEmpty),
 } satisfies EntriesOf<WorkspaceKey>);
 
 export const ArtifactMetaSchema = v.object({
+  workflow: v.optional(v.picklist(WORKFLOW_KINDS)),
   cwd: v.optional(v.string()),
   agent: v.optional(v.string()),
   agentSessionId: v.optional(v.string()),
   planPath: v.optional(v.string()),
+  prototypePath: v.optional(v.string()),
   pr: v.optional(v.string()),
   herdrPane: v.optional(v.string()),
   title: v.optional(v.string()),
+  workbench: v.optional(v.boolean()),
+  snapshot: v.optional(v.boolean()),
 } satisfies EntriesOf<ArtifactMeta>);
 
+export const DiffFileContentsSchema = v.object({
+  path: NonEmpty,
+  oldContents: v.string(),
+  newContents: v.string(),
+  status: v.picklist(["added", "modified", "deleted"]),
+} satisfies EntriesOf<DiffFileContents>);
+
 export const ArtifactSchema = v.object({
-  type: v.picklist(["plan", "diff"]),
+  // Derived from the schema's runtime union: a new primitive extends the wire
+  // contract without touching this file.
+  type: v.picklist(ARTIFACT_TYPES),
   content: v.string(),
   meta: v.optional(ArtifactMetaSchema, {}),
+  files: v.optional(v.array(DiffFileContentsSchema)),
 } satisfies EntriesOf<Artifact>);
 
 export const AnchorSchema = v.object({
@@ -60,22 +90,80 @@ export const AnchorSchema = v.object({
   prefix: v.optional(v.string(), ""),
   suffix: v.optional(v.string(), ""),
   blockIndex: v.optional(v.number()),
+  endBlockIndex: v.optional(v.number()),
   start: v.optional(v.number()),
   end: v.optional(v.number()),
+  selector: v.optional(v.string()),
 } satisfies EntriesOf<Anchor>);
 
+/** The surface a note was made on; absent means the reviewed artifact. */
+export const AnnotationTargetSchema: v.GenericSchema<AnnotationTarget> = v.variant("kind", [
+  v.object({ kind: v.literal("artifact") }),
+  v.object({ kind: v.literal("file"), path: NonEmpty, rev: v.picklist(["worktree", "head"]) }),
+  v.object({ kind: v.literal("welcome") }),
+]);
+
 /** Wire annotations arrive without createdAt - the daemon stamps it. */
 export const AnnotationSchema = v.object({
   id: NonEmpty,
-  /** Open kind set (#2): built-ins are comment and suggestion. */
+  /** Open kind set: the built-in is comment. */
   kind: NonEmpty,
   anchor: AnchorSchema,
+  target: v.optional(AnnotationTargetSchema),
   body: v.string(),
   orphan: v.optional(v.boolean()),
+  author: v.optional(v.string()),
+  replyTo: v.optional(NonEmpty),
+  resolution: v.optional(
+    v.object({
+      revision: v.number(),
+      source: v.picklist(["agent", "drift"]),
+    }),
+  ),
 } satisfies EntriesOf<Omit<Annotation, "createdAt">>);
 
 const SessionId = NonEmpty;
 
+/** A stored annotation: the wire shape plus the daemon-stamped createdAt. */
+export const FullAnnotationSchema = v.object({
+  ...AnnotationSchema.entries,
+  createdAt: v.string(),
+} satisfies EntriesOf<Annotation>);
+
+export const IdentitySchema = v.object({
+  id: NonEmpty,
+  provider: v.picklist(["ssh", "github"]),
+  name: v.optional(v.string()),
+  handle: v.optional(v.string()),
+} satisfies EntriesOf<Identity>);
+
+export const ShareLinkSchema = v.object({
+  id: NonEmpty,
+  name: v.optional(v.string()),
+  requireAuth: v.boolean(),
+  allowlist: v.array(NonEmpty),
+  owner: v.optional(v.string()),
+  shareBranch: v.optional(v.string()),
+} satisfies EntriesOf<ShareLink>);
+
+export const HarnessBindingSchema = v.object({
+  id: NonEmpty,
+  threadId: NonEmpty,
+  harness: NonEmpty,
+  harnessSessionId: NonEmpty,
+  createdAt: NonEmpty,
+  approvedRetryMessageId: v.optional(NonEmpty),
+} satisfies EntriesOf<HarnessBinding>);
+
+export const DeliverySchema = v.object({
+  id: NonEmpty,
+  messageId: NonEmpty,
+  bindingId: NonEmpty,
+  status: v.picklist(["pending", "acknowledged"]),
+  createdAt: NonEmpty,
+  acknowledgedAt: v.optional(NonEmpty),
+} satisfies EntriesOf<Delivery>);
+
 export const Params = {
   "session.create": v.object({ workspace: WorkspaceSchema, artifact: ArtifactSchema }),
   "session.get": v.object({ id: SessionId }),
@@ -90,20 +178,117 @@ export const Params = {
   "session.wait": v.object({
     id: SessionId,
     // clamped: a negative or absurd timeout is a client bug, not a daemon one
-    timeoutMs: v.optional(v.pipe(v.number(), v.minValue(0), v.maxValue(24 * 60 * 60 * 1000)), 60_000),
+    timeoutMs: v.optional(
+      v.pipe(v.number(), v.minValue(0), v.maxValue(24 * 60 * 60 * 1000)),
+      60_000,
+    ),
+  }),
+  "session.annotate": v.object({
+    id: SessionId,
+    annotation: AnnotationSchema,
+    authorName: v.optional(v.string()),
+  }),
+  // "session.comment" is the primary annotate method; "session.annotate" stays an accepted alias
+  "session.comment": v.object({
+    id: SessionId,
+    annotation: AnnotationSchema,
+    authorName: v.optional(v.string()),
   }),
-  "session.annotate": v.object({ id: SessionId, annotation: AnnotationSchema }),
   "session.removeAnnotation": v.object({ id: SessionId, annotationId: NonEmpty }),
+  "session.setParticipantName": v.object({ id: SessionId, author: NonEmpty, name: NonEmpty }),
   "session.setWorkingCopy": v.object({ id: SessionId, workingCopy: v.optional(v.string()) }),
-  "session.resolve": v.object({
+  "session.cutBlock": v.object({
+    id: SessionId,
+    blockIndex: v.pipe(v.number(), v.integer(), v.minValue(0)),
+  }),
+  "session.restoreBlock": v.object({
+    id: SessionId,
+    baseBlockIndex: v.pipe(v.number(), v.integer(), v.minValue(0)),
+    line: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+  }),
+  "session.curate": v.object({
     id: SessionId,
-    verdictKind: v.picklist(["comment", "approve", "request_changes"]),
+    rejections: v.array(
+      v.object({
+        path: NonEmpty,
+        hunkIndex: v.pipe(v.number(), v.integer(), v.minValue(0)),
+        changeIndex: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0))),
+      } satisfies EntriesOf<HunkRejection>),
+    ),
+  }),
+  "session.setViewed": v.object({ id: SessionId, viewedPaths: v.array(v.string()) }),
+  "session.setTitle": v.object({ id: SessionId, title: v.string() }),
+  "session.projectFiles": v.object({ id: SessionId }),
+  "session.fileContents": v.object({ id: SessionId, path: NonEmpty }),
+  "repo.files": v.object({ cwd: NonEmpty }),
+  "repo.fileContents": v.object({ cwd: NonEmpty, path: NonEmpty }),
+  "repo.changes": v.object({ cwd: NonEmpty }),
+  "repo.diff": v.object({ cwd: NonEmpty }),
+  "session.workbench": v.object({ cwd: NonEmpty }),
+  "session.navigate": v.object({
+    id: SessionId,
+    entryId: NonEmpty,
+    summary: v.optional(v.string()),
+    // stand on this branch first, so a move on another branch is one request
+    branch: v.optional(NonEmpty),
+  }),
+  "session.branch": v.object({ id: SessionId, name: NonEmpty }),
+  "session.switch": v.object({ id: SessionId, branch: NonEmpty }),
+  "session.label": v.object({ id: SessionId, label: NonEmpty }),
+  "session.fork": v.object({ id: SessionId }),
+  "session.refreshDiff": v.object({ id: SessionId }),
+  "session.setShareId": v.object({ id: SessionId, shareId: NonEmpty }),
+  "session.setShares": v.object({ id: SessionId, shares: v.array(ShareLinkSchema) }),
+  "session.setAccess": v.object({ id: SessionId, githubLogins: v.array(NonEmpty) }),
+  "session.delete": v.object({ id: SessionId }),
+  "session.mergeShared": v.object({
+    id: SessionId,
+    annotations: v.array(FullAnnotationSchema),
+    participants: v.optional(v.array(IdentitySchema)),
+    // the removal entries a share recorded, carried by id so a merge applies each once
+    removals: v.optional(
+      v.array(v.object({ id: NonEmpty, annotationId: NonEmpty, createdAt: v.string() })),
+    ),
+  }),
+  "session.sendMessage": v.object({
+    id: SessionId,
+    outcome: v.picklist(["approved", "changes_requested"]),
     summary: v.optional(v.string(), ""),
+    actionBodies: v.optional(v.record(v.string(), v.string())),
+  }),
+  "harness.bind": v.object({
+    threadId: SessionId,
+    harness: NonEmpty,
+    harnessSessionId: NonEmpty,
+  }),
+  "harness.getBinding": v.object({ bindingId: NonEmpty }),
+  "harness.consumeApprovedRetry": v.object({
+    bindingId: NonEmpty,
+    messageId: NonEmpty,
+    content: v.string(),
+  }),
+  "delivery.pending": v.object({ bindingId: NonEmpty }),
+  "delivery.acknowledge": v.object({ deliveryId: NonEmpty }),
+  "session.submitRevision": v.object({
+    id: SessionId,
+    content: v.string(),
+    files: v.optional(v.array(DiffFileContentsSchema)),
+    /** Annotation ids the agent acted on; each is marked addressed. */
+    addressedAnnotationIds: v.optional(v.array(NonEmpty), []),
   }),
-  "session.submitRevision": v.object({ id: SessionId, content: v.string() }),
   "events.subscribe": v.object({}),
   "daemon.ping": v.object({}),
+  // the owner token proves ownership; without it a request for owner stays a collaborator
+  "daemon.hello": v.object({
+    role: v.picklist(["owner", "collaborator", "agent"]),
+    token: v.optional(v.string()),
+    // the author a non-owner acts as, bound once for the connection
+    author: v.optional(NonEmpty),
+  }),
   "daemon.shutdown": v.object({}),
+  // herdr adapter scratch: the review's opened tab, kept off the session record.
+  "herdr.getTab": v.object({ id: SessionId }),
+  "herdr.setTab": v.object({ id: SessionId, tabId: NonEmpty, paneId: NonEmpty }),
 } as const;
 
 export type MethodName = keyof typeof Params;
@@ -113,13 +298,22 @@ export function isKnownMethod(method: string): method is MethodName {
 }
 
 /** Validate params for a method, or throw a DaemonError the client can read. */
-export function parseParams<M extends MethodName>(method: M, params: unknown): v.InferOutput<(typeof Params)[M]> {
+export function parseParams<M extends MethodName>(
+  method: M,
+  params: Request["params"],
+): v.InferOutput<(typeof Params)[M]> {
   const result = v.safeParse(Params[method], params ?? {});
+
   if (!result.success) {
     const issue = result.issues[0]!;
-    const path = issue.path?.map((p) => String(p.key)).join(".") ?? "";
-    throw new DaemonError("invalid_params", `${method}: ${path ? path + " - " : ""}${issue.message}`);
+    const path = issue.path?.map((pathSegment) => String(pathSegment.key)).join(".") ?? "";
+
+    throw new DaemonError(
+      "invalid_params",
+      `${method}: ${path ? path + " - " : ""}${issue.message}`,
+    );
   }
+
   return result.output;
 }
 
@@ -129,31 +323,108 @@ export const RevisionSchema = v.object({
   submittedAt: v.string(),
 } satisfies EntriesOf<Revision>);
 
-export const VerdictSchema = v.object({
-  kind: v.picklist(["comment", "approve", "request_changes"]),
+export const MessageSchema = v.object({
+  id: NonEmpty,
+  outcome: v.picklist(["approved", "changes_requested"]),
   summary: v.string(),
-  feedback: v.string(),
-  resolvedAt: v.string(),
-} satisfies EntriesOf<Verdict>);
+  body: v.string(),
+  sentAt: v.string(),
+} satisfies EntriesOf<Message>);
+
+export const PendingDeliverySchema = v.object({
+  delivery: DeliverySchema,
+  message: MessageSchema,
+} satisfies EntriesOf<PendingDelivery>);
+
+const EntryBaseEntries = {
+  id: NonEmpty,
+  parentId: v.nullable(NonEmpty),
+  createdAt: v.string(),
+};
+
+/** One record of a session's history; the tree pointers plus the entry's own fields. */
+export const SessionEntrySchema = v.variant("type", [
+  v.object({
+    ...EntryBaseEntries,
+    type: v.literal("revision"),
+    by: v.picklist(["agent", "reviewer"]),
+    content: v.string(),
+  }),
+  v.object({ ...EntryBaseEntries, type: v.literal("comment"), annotationId: NonEmpty }),
+  v.object({ ...EntryBaseEntries, type: v.literal("comment-removed"), annotationId: NonEmpty }),
+  v.object({ ...EntryBaseEntries, type: v.literal("message"), message: MessageSchema }),
+  v.object({
+    ...EntryBaseEntries,
+    type: v.literal("branch-summary"),
+    text: v.string(),
+    abandoned: v.array(NonEmpty),
+  }),
+]);
+
+export const SessionHistorySchema = v.pipe(
+  v.object({
+    entries: v.array(SessionEntrySchema),
+    tips: v.record(v.string(), NonEmpty),
+    branch: NonEmpty,
+    labels: v.record(v.string(), v.string()),
+  } satisfies EntriesOf<SessionHistory>),
+  // the shape is not enough: the tree itself must hold, or a walk hangs or rewires the path
+  v.rawCheck(({ dataset, addIssue }) => {
+    if (!dataset.typed) return;
+    const problem = validateHistory(dataset.value);
+
+    if (problem !== null) addIssue({ message: `history: ${problem}` });
+  }),
+);
 
 /** Persisted records are validated on recovery: a bad file is skipped, not fatal. */
-export const SessionRecordSchema = v.object({
+export const ThreadRecordSchema = v.object({
   schemaVersion: v.literal(SCHEMA_VERSION),
   id: NonEmpty,
   workspace: WorkspaceSchema,
   artifact: ArtifactSchema,
   revisions: v.array(RevisionSchema),
-  annotations: v.array(v.object({ ...AnnotationSchema.entries, createdAt: v.string() } satisfies EntriesOf<Annotation>)),
+  annotations: v.array(FullAnnotationSchema),
+  history: v.optional(SessionHistorySchema),
+  curation: v.optional(
+    v.array(
+      v.object({
+        path: NonEmpty,
+        hunkIndex: v.number(),
+        changeIndex: v.optional(v.number()),
+      } satisfies EntriesOf<HunkRejection>),
+    ),
+  ),
   workingCopy: v.optional(v.string()),
-  verdict: v.nullable(VerdictSchema),
+  viewedPaths: v.optional(v.array(v.string())),
+  message: v.nullable(MessageSchema),
   status: v.picklist(["pending", "resolved"]),
   createdAt: v.string(),
-} satisfies EntriesOf<ReviewSession>);
+  shelvedAnnotations: v.optional(v.array(FullAnnotationSchema)),
+  parentSessionId: v.optional(v.string()),
+  shares: v.optional(v.array(ShareLinkSchema)),
+  shareId: v.optional(v.string()),
+  shareBranch: v.optional(v.string()),
+  owner: v.optional(v.string()),
+  access: v.optional(
+    v.object({ githubLogins: v.array(NonEmpty) } satisfies EntriesOf<ShareAccess>),
+  ),
+  participants: v.optional(v.array(IdentitySchema)),
+} satisfies EntriesOf<Thread>);
+
+export function validateThreadRecord(
+  raw: Parameters<typeof v.safeParse>[1],
+): { ok: true; value: v.InferOutput<typeof ThreadRecordSchema> } | { ok: false; error: string } {
+  const result = v.safeParse(ThreadRecordSchema, raw);
 
-export function validateSessionRecord(raw: unknown): { ok: true; value: v.InferOutput<typeof SessionRecordSchema> } | { ok: false; error: string } {
-  const result = v.safeParse(SessionRecordSchema, raw);
   if (result.success) return { ok: true, value: result.output };
   const issue = result.issues[0]!;
-  const path = issue.path?.map((p) => String(p.key)).join(".") ?? "";
+  const path = issue.path?.map((pathSegment) => String(pathSegment.key)).join(".") ?? "";
+
   return { ok: false, error: `${path ? path + ": " : ""}${issue.message}` };
 }
+
+/** @deprecated use ThreadRecordSchema */
+export const SessionRecordSchema = ThreadRecordSchema;
+/** @deprecated use validateThreadRecord */
+export const validateSessionRecord = validateThreadRecord;

package/src/version.ts

@@ -0,0 +1,6 @@
+/** The daemon's build version, read from the package manifest - the handshake
+ *  uses it so a client never keeps talking to a daemon from an earlier build. */
+
+import manifest from "../package.json" with { type: "json" };
+
+export const DAEMON_VERSION: string = manifest.version;

package/src/working-tree.ts

@@ -0,0 +1,149 @@
+/** Working-tree diff capture for `cueloop diff`, untracked files included. */
+
+import { join } from "node:path";
+import type { DiffFileContents, DiffFileStatus } from "@cueloop/schema";
+
+async function git(args: string[], cwd: string): Promise<string | null> {
+  const gitProcess = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
+  const stdout = await new Response(gitProcess.stdout).text();
+
+  if ((await gitProcess.exited) !== 0) return null;
+
+  return stdout.trim();
+}
+
+/** Map a `git diff --name-status` letter to a diff status; renames/copies read as modified. */
+function statusFromCode(code: string): DiffFileStatus {
+  const letter = code.charAt(0);
+  if (letter === "D") return "deleted";
+  if (letter === "A") return "added";
+
+  return "modified";
+}
+
+/**
+ * The working tree's changed files as repo-relative path plus status - a fast listing for the changes
+ * navigator that never reads file contents (unlike workingTreeDiff, which captures full curation copies).
+ * Uses tab-separated name-status so a trimmed leading column can never shift the parse.
+ */
+export async function workingChangeList(
+  cwd = process.cwd(),
+): Promise<{ path: string; status: DiffFileStatus }[]> {
+  const changes: { path: string; status: DiffFileStatus }[] = [];
+  const tracked = (await git(["diff", "--name-status", "HEAD"], cwd)) ?? "";
+
+  for (const line of tracked.split("\n")) {
+    if (line.trim().length === 0) continue;
+    const parts = line.split("\t");
+    // a rename is "R100<tab>old<tab>new"; the new path (last field) is what the reviewer opens
+    changes.push({ path: parts[parts.length - 1]!, status: statusFromCode(parts[0]!) });
+  }
+
+  const untracked = (await git(["ls-files", "--others", "--exclude-standard"], cwd)) ?? "";
+
+  for (const path of untracked.split("\n")) {
+    if (path.trim().length > 0) changes.push({ path, status: "added" });
+  }
+
+  return changes;
+}
+
+/** The blob at HEAD for a path, or "" when the path is not in HEAD (new file). */
+async function headContents(path: string, cwd: string): Promise<string> {
+  const gitProcess = Bun.spawn(["git", "show", `HEAD:${path}`], {
+    cwd,
+    stdout: "pipe",
+    stderr: "ignore",
+  });
+  const stdout = await new Response(gitProcess.stdout).text();
+
+  return (await gitProcess.exited) === 0 ? stdout : "";
+}
+
+/** The working-tree file, or "" when it is gone (deleted). */
+async function workingContents(path: string, cwd: string): Promise<string> {
+  try {
+    return await Bun.file(join(cwd, path)).text();
+  } catch {
+    return "";
+  }
+}
+
+/** A NUL byte marks content git would treat as binary - not text-curatable. */
+function looksBinary(text: string): boolean {
+  for (let index = 0; index < text.length; index++) {
+    if (text.charCodeAt(index) === 0) return true;
+  }
+
+  return false;
+}
+
+/**
+ * Full old/new contents for every tracked change against HEAD, classified by
+ * git's own status letter. Renames/copies and binary files are omitted: a
+ * path+text pair cannot express a rename header or a binary blob, so curation
+ * would emit a patch that drops the old path or corrupts the file - leaving them
+ * out keeps those changes in the patch but simply not curatable. The
+ * NUL-delimited stream survives paths with spaces or unicode.
+ */
+async function trackedFileContents(cwd: string): Promise<DiffFileContents[]> {
+  const nameStatus = (await git(["diff", "HEAD", "--name-status", "-z"], cwd)) ?? "";
+  const tokens = nameStatus.split("\0").filter((token) => token.length > 0);
+  const files: DiffFileContents[] = [];
+  let cursor = 0;
+
+  while (cursor < tokens.length) {
+    const code = tokens[cursor++]![0];
+
+    if (code === "R" || code === "C") {
+      cursor += 2;
+      continue;
+    }
+    const path = tokens[cursor++]!;
+    const oldContents = code === "A" ? "" : await headContents(path, cwd);
+    const newContents = code === "D" ? "" : await workingContents(path, cwd);
+
+    if (looksBinary(oldContents) || looksBinary(newContents)) continue;
+    const status = code === "A" ? "added" : code === "D" ? "deleted" : "modified";
+
+    files.push({ path, oldContents, newContents, status });
+  }
+
+  return files;
+}
+
+export interface WorkingTreeDiff {
+  patch: string;
+  /** Full file contents per curatable changed file, keeping curation applyable. */
+  files: DiffFileContents[];
+}
+
+export async function workingTreeDiff(cwd = process.cwd()): Promise<WorkingTreeDiff> {
+  const tracked = (await git(["diff", "HEAD"], cwd)) ?? "";
+  const files = await trackedFileContents(cwd);
+  // untracked files included by default
+  const untrackedList = (await git(["ls-files", "--others", "--exclude-standard"], cwd)) ?? "";
+  let untracked = "";
+
+  for (const file of untrackedList.split("\n").filter(Boolean)) {
+    // `git diff --no-index` exits 1 when the files differ - that is success here
+    const gitProcess = Bun.spawn(["git", "diff", "--no-index", "--", "/dev/null", file], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const stdout = await new Response(gitProcess.stdout).text();
+    const code = await gitProcess.exited;
+
+    if ((code === 0 || code === 1) && stdout.trim()) {
+      untracked += stdout.trim() + "\n";
+      const newContents = await workingContents(file, cwd);
+
+      if (!looksBinary(newContents)) {
+        files.push({ path: file, oldContents: "", newContents, status: "added" });
+      }
+    }
+  }
+
+  return { patch: [tracked, untracked].filter(Boolean).join("\n"), files };
+}