impel-cli 0.7.0

package/src/commands/tasks.js

@@ -0,0 +1,359 @@
+import fs from "node:fs";
+
+import { parseFlags } from "../args.js";
+import { loadConfig, resolveDefaultAppUrl, normalizeGatewayUrl, redactSecretText } from "../config.js";
+import {
+  ensureTenantSelection,
+  PAT_SCOPE_TASKS,
+  PRODUCT_ACCESS_GATEWAY,
+  PRODUCT_ACCESS_WORKSPACE,
+} from "../tenants.js";
+
+const VALID_PROGRESS = new Set(["none", "todo", "progress", "review", "done"]);
+const VALID_PRIORITY = new Set(["none", "urgent", "high", "medium", "low"]);
+const VALID_LABELS = new Set(["feature", "bug", "engineering", "design", "product"]);
+
+const HELP = `impel tasks - CRUD tickets in Impel
+
+Usage:
+  impel tasks list [--org <org>] [--scope visible|done|all] [--json]
+  impel tasks get <id> [--org <org>] [--json]
+  impel tasks create --title <title> [--description <md> | --description-file <path>] [options] [--json]
+  impel tasks update <id> [options] [--json]
+  impel tasks delete <id> --yes [--org <org>] [--json]
+
+Aliases:
+  impel task ...
+  impel tickets ...
+  impel ticket ...
+
+Options:
+  --org <org>                       Target org id. Defaults to the selected tenant.
+  --app <url>                       Override app URL for this command.
+  --title <title>                   Ticket title.
+  --description <markdown>          Ticket body markdown.
+  --description-file <path>         Read ticket body markdown from a file.
+  --description-mode replace|append Description update mode. Default: replace.
+  --progress none|todo|progress|review|done
+  --priority none|urgent|high|medium|low
+  --labels <csv>                    Full label set, e.g. feature,engineering. Empty clears labels.
+  --assignee <id|none>              Assignee member id, or "none".
+  --assigned-to <id|none>           Alias for --assignee.
+  --due <YYYY-MM-DD|empty>          Due date, or empty string to clear.
+  --json                            Print raw JSON response.
+`;
+
+class UsageError extends Error {}
+
+function fail(message) {
+  throw new UsageError(message);
+}
+
+function flagSpec() {
+  return {
+    app: { type: "string" },
+    org: { type: "string" },
+    scope: { type: "string" },
+    json: { type: "boolean" },
+    title: { type: "string" },
+    description: { type: "string" },
+    "description-file": { type: "string" },
+    "description-mode": { type: "string" },
+    progress: { type: "string" },
+    priority: { type: "string" },
+    labels: { type: "string" },
+    assignee: { type: "string" },
+    "assigned-to": { type: "string" },
+    due: { type: "string" },
+    yes: { type: "boolean" },
+  };
+}
+
+function requireConfig(flags) {
+  const config = loadConfig();
+  if (!config?.pat) {
+    fail("impel: not authenticated. Run `impel setup` (or `impel auth`) first.");
+  }
+  const appUrl = normalizeGatewayUrl(flags.app || config.appUrl || resolveDefaultAppUrl());
+  return { config, pat: config.pat, appUrl };
+}
+
+async function requestJson({ flags, path, query, method = "GET", body }) {
+  const { config, pat, appUrl } = requireConfig(flags);
+  const url = new URL(path, appUrl);
+  const selected = await ensureTenantSelection(config, { refresh: true });
+  if (selected.productAccess === PRODUCT_ACCESS_GATEWAY) {
+    fail("impel tasks: Gateway members do not have workspace task access.");
+  }
+  if (selected.productAccess !== PRODUCT_ACCESS_WORKSPACE) {
+    fail("impel tasks: the control plane did not return a live Workspace entitlement; retry after it is upgraded.");
+  }
+  if (!Array.isArray(selected.scopes)) {
+    fail("impel tasks: the control plane did not return live PAT scopes; retry after it is upgraded.");
+  }
+  if (!selected.scopes.includes(PAT_SCOPE_TASKS)) {
+    fail("impel tasks: this PAT is missing the \"tasks\" scope; create a fresh PAT in Impel Gateway setup, then run `impel auth --pat <pat>`.");
+  }
+  const selectedOrgId = flags.org || selected.tenantId;
+  const resolvedQuery = { ...(query || {}) };
+  if (Object.hasOwn(resolvedQuery, "orgId") && !resolvedQuery.orgId) {
+    resolvedQuery.orgId = selectedOrgId;
+  }
+  const resolvedBody = body && !body.orgId && selectedOrgId
+    ? { ...body, orgId: selectedOrgId }
+    : body;
+  for (const [key, value] of Object.entries(resolvedQuery)) {
+    if (value !== undefined && value !== null && value !== "") {
+      url.searchParams.set(key, value);
+    }
+  }
+
+  let res;
+  try {
+    res = await fetch(url, {
+      method,
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${pat}`,
+        ...(resolvedBody === undefined ? {} : { "content-type": "application/json" }),
+      },
+      body: resolvedBody === undefined ? undefined : JSON.stringify(resolvedBody),
+    });
+  } catch (err) {
+    fail(`impel tasks: could not reach ${appUrl}: ${redactSecretText(err.message)}`);
+  }
+
+  const text = await res.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = { error: text || res.statusText };
+  }
+
+  if (!res.ok) {
+    const message = redactSecretText(payload?.error || `${res.status} ${res.statusText}`.trim());
+    fail(`impel tasks: ${message}`);
+  }
+  return payload;
+}
+
+function parseCsv(value, valid, label) {
+  if (value === undefined) return undefined;
+  const items = String(value)
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  for (const item of items) {
+    if (!valid.has(item)) {
+      fail(`impel tasks: invalid ${label} "${item}".`);
+    }
+  }
+  return items;
+}
+
+function validateOne(value, valid, label) {
+  if (value === undefined) return undefined;
+  if (!valid.has(value)) fail(`impel tasks: invalid ${label} "${value}".`);
+  return value;
+}
+
+function descriptionFromFlags(flags) {
+  const inline = flags.description;
+  const file = flags["description-file"];
+  if (inline !== undefined && file !== undefined) {
+    fail("impel tasks: use either --description or --description-file, not both.");
+  }
+  if (file !== undefined) {
+    try {
+      return fs.readFileSync(file, "utf8");
+    } catch (err) {
+      fail(`impel tasks: could not read ${file}: ${err.message}`);
+    }
+  }
+  return inline;
+}
+
+function mutationBody(flags, { requireTitle = false } = {}) {
+  const body = {};
+  if (flags.org !== undefined) body.orgId = flags.org;
+
+  if (flags.title !== undefined) body.title = flags.title;
+  if (requireTitle && !body.title?.trim()) {
+    fail("impel tasks create: --title is required.");
+  }
+
+  const description = descriptionFromFlags(flags);
+  if (description !== undefined) body.descriptionMarkdown = description;
+
+  const mode = flags["description-mode"];
+  if (mode !== undefined) {
+    if (mode !== "replace" && mode !== "append") {
+      fail('impel tasks: --description-mode must be "replace" or "append".');
+    }
+    body.descriptionMode = mode;
+  }
+
+  const progress = validateOne(flags.progress, VALID_PROGRESS, "progress");
+  if (progress !== undefined) body.progress = progress;
+
+  const priority = validateOne(flags.priority, VALID_PRIORITY, "priority");
+  if (priority !== undefined) body.priority = priority;
+
+  const labels = parseCsv(flags.labels, VALID_LABELS, "label");
+  if (labels !== undefined) body.labels = labels;
+
+  const assignedTo = flags.assignee ?? flags["assigned-to"];
+  if (assignedTo !== undefined) body.assignedTo = assignedTo;
+
+  if (flags.due !== undefined) body.dueDate = flags.due;
+
+  return body;
+}
+
+function printJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+
+function truncate(value, max) {
+  const text = String(value ?? "");
+  return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+
+function printTable(tasks) {
+  if (!tasks.length) {
+    console.log("No tasks found.");
+    return;
+  }
+  const rows = tasks.map((task) => [
+    task.issueId,
+    task.progress || "none",
+    task.priority || "none",
+    task.assignedTo || "unassigned",
+    truncate(task.title || "Untitled", 80),
+  ]);
+  const headers = ["ID", "Progress", "Priority", "Assignee", "Title"];
+  const widths = headers.map((header, i) =>
+    Math.max(header.length, ...rows.map((row) => String(row[i]).length))
+  );
+  const line = (cols) =>
+    cols.map((col, i) => String(col).padEnd(widths[i])).join("  ").trimEnd();
+  console.log(line(headers));
+  console.log(line(widths.map((width) => "-".repeat(width))));
+  for (const row of rows) console.log(line(row));
+}
+
+function printTask(task, { orgId, markdown } = {}) {
+  console.log(`${task.issueId}: ${task.title || "Untitled"}`);
+  if (orgId) console.log(`Org:       ${orgId}`);
+  console.log(`Progress:  ${task.progress || "none"}`);
+  console.log(`Priority:  ${task.priority || "none"}`);
+  console.log(`Assignee:  ${task.assignedTo || "unassigned"}`);
+  console.log(`Labels:    ${(task.labels || []).join(", ") || "none"}`);
+  if (task.latestRunId) console.log(`Run:       ${task.latestRunId} (${task.runStatus || "unknown"})`);
+  if (markdown) {
+    console.log("");
+    console.log(markdown);
+  }
+}
+
+export async function cmdTasks(argv) {
+  const [subcommand, ...rest] = argv;
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    console.log(HELP);
+    return;
+  }
+
+  const { flags, positionals } = parseFlags(rest, flagSpec());
+  try {
+    switch (subcommand) {
+      case "list": {
+        const scope = flags.scope || "all";
+        if (!["visible", "done", "all"].includes(scope)) {
+          fail("impel tasks list: --scope must be visible, done, or all.");
+        }
+        const payload = await requestJson({
+          flags,
+          path: "/api/cli/tasks",
+          query: { orgId: flags.org, scope },
+        });
+        if (flags.json) return printJson(payload);
+        printTable(payload.tasks || []);
+        return;
+      }
+
+      case "get": {
+        const issueId = positionals[0];
+        if (!issueId) fail("impel tasks get: missing task id.");
+        const payload = await requestJson({
+          flags,
+          path: `/api/cli/tasks/${encodeURIComponent(issueId)}`,
+          query: { orgId: flags.org },
+        });
+        if (flags.json) return printJson(payload);
+        printTask(payload.task, { orgId: payload.orgId, markdown: payload.markdown });
+        return;
+      }
+
+      case "create": {
+        const body = mutationBody(flags, { requireTitle: true });
+        const payload = await requestJson({
+          flags,
+          path: "/api/cli/tasks",
+          method: "POST",
+          body,
+        });
+        if (flags.json) return printJson(payload);
+        console.log(`Created ${payload.task.issueId}`);
+        printTask(payload.task, { orgId: payload.orgId });
+        return;
+      }
+
+      case "update": {
+        const issueId = positionals[0];
+        if (!issueId) fail("impel tasks update: missing task id.");
+        const body = mutationBody(flags);
+        if (Object.keys(body).filter((key) => key !== "orgId").length === 0) {
+          fail("impel tasks update: pass at least one field to update.");
+        }
+        const payload = await requestJson({
+          flags,
+          path: `/api/cli/tasks/${encodeURIComponent(issueId)}`,
+          method: "PATCH",
+          body,
+        });
+        if (flags.json) return printJson(payload);
+        console.log(`Updated ${payload.task.issueId}`);
+        printTask(payload.task, { orgId: payload.orgId });
+        return;
+      }
+
+      case "delete": {
+        const issueId = positionals[0];
+        if (!issueId) fail("impel tasks delete: missing task id.");
+        if (!flags.yes) {
+          fail("impel tasks delete: refusing to delete without --yes.");
+        }
+        const payload = await requestJson({
+          flags,
+          path: `/api/cli/tasks/${encodeURIComponent(issueId)}`,
+          query: { orgId: flags.org },
+          method: "DELETE",
+        });
+        if (flags.json) return printJson(payload);
+        console.log(`Deleted ${payload.issueId}`);
+        return;
+      }
+
+      default:
+        fail(`impel tasks: unknown subcommand "${subcommand}".`);
+    }
+  } catch (err) {
+    if (err instanceof UsageError) {
+      console.error(err.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw err;
+  }
+}

package/src/commands/tenant.js

@@ -0,0 +1,77 @@
+import { parseFlags } from "../args.js";
+import { loadConfig } from "../config.js";
+import { ensureTenantSelection, productAccessLabel, selectTenant } from "../tenants.js";
+import { cmdApps } from "./apps.js";
+import { cmdLaunch } from "./launch.js";
+
+const HELP = `impel tenant - select the organization used by Impel sessions
+
+Usage:
+  impel tenant list
+  impel tenant current
+  impel tenant use <org-slug> [--launch claude|codex|apps]
+
+Aliases: impel tenants ..., impel org ...
+`;
+
+function requireConfig() {
+  const config = loadConfig();
+  if (!config?.pat) throw new Error("not authenticated; run `impel setup` (or `impel auth`) first");
+  return config;
+}
+
+function printTenants(listing, selectedId) {
+  console.log(`Access: ${productAccessLabel(listing.productAccess)}`);
+  for (const tenant of listing.tenants) {
+    const markers = [
+      tenant.id === selectedId ? "selected" : null,
+      tenant.id === listing.defaultTenantId ? "default" : null,
+    ].filter(Boolean);
+    console.log(`${tenant.id}${markers.length ? ` (${markers.join(", ")})` : ""}\t${tenant.name}`);
+  }
+}
+
+export async function cmdTenant(argv) {
+  const [action = "current", ...rest] = argv;
+  if (["help", "--help", "-h"].includes(action)) {
+    console.log(HELP);
+    return;
+  }
+  const config = requireConfig();
+
+  if (action === "list") {
+    const selected = await ensureTenantSelection(config, { refresh: true });
+    printTenants(
+      {
+        tenants: selected.tenants,
+        defaultTenantId: selected.defaultTenantId,
+        // productAccess is global to the user, not an org role.
+        productAccess: selected.productAccess,
+      },
+      selected.tenantId,
+    );
+    return;
+  }
+
+  if (action === "current") {
+    const selected = await ensureTenantSelection(config, { refresh: true });
+    console.log(selected.tenantId);
+    return;
+  }
+
+  if (action !== "use") throw new Error(`unknown tenant action "${action}"; use list, current, or use`);
+  const { flags, positionals } = parseFlags(rest, { launch: { type: "string" } });
+  const tenantId = positionals[0];
+  if (!tenantId) throw new Error("tenant use requires an org slug; run `impel tenant list`");
+  const { tenant } = await selectTenant(config, tenantId);
+  console.log(`Tenant -> ${tenant.id} (${tenant.name})`);
+
+  const launch = flags.launch;
+  if (!launch) {
+    console.log("Next: `impel claude`, `impel codex`, or `impel app open`.");
+    return;
+  }
+  if (launch === "claude" || launch === "codex") return cmdLaunch(launch, []);
+  if (launch === "apps") return cmdApps(["open", "all"]);
+  throw new Error(`unknown launch target "${launch}"; use claude, codex, or apps`);
+}

package/src/commands/token.js

@@ -0,0 +1,25 @@
+import { loadConfig } from "../config.js";
+import { parseFlags } from "../args.js";
+import { ensureTenantSelection, normalizeTenantId, tenantCredential } from "../tenants.js";
+
+// This is the `apiKeyHelper` / auth-command contract: stdout (and only
+// stdout) must be exactly the bearer token, nothing else. Both Claude Code's
+// apiKeyHelper and Codex CLI's `model_providers.<id>.auth.command` call this.
+export async function cmdToken(argv = []) {
+  const { flags } = parseFlags(argv, { tenant: { type: "string" } });
+  const config = loadConfig();
+  if (!config?.pat) {
+    process.stderr.write("impel: not authenticated. Run `impel setup` (or `impel auth`) first.\n");
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const tenantId = flags.tenant
+      ? normalizeTenantId(flags.tenant)
+      : (await ensureTenantSelection(config)).tenantId;
+    process.stdout.write(`${tenantCredential(config.pat, tenantId)}\n`);
+  } catch (error) {
+    process.stderr.write(`impel: ${error.message}\n`);
+    process.exitCode = 1;
+  }
+}

package/src/commands/update.js

@@ -0,0 +1,217 @@
+// `impel update` — bring everything current in one command: the CLI itself
+// (npm reinstall from the public package), then the managed desktop apps/profiles, then
+// skills. The app step re-executes the freshly installed CLI so the new code
+// performs it.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+import { parseFlags } from "../args.js";
+import { CLAUDE_CONFIG_ID, appPaths } from "../apps.js";
+import { loadConfig, redactSecretText } from "../config.js";
+import { nativeCommandInvocation } from "../nativeProcess.js";
+import { windowsClaudeUserData } from "../windowsApps.js";
+import {
+  fetchRemoteVersion,
+  installedVersion,
+  isNewerVersion,
+  refreshUpdateCache,
+  updateInstallSpec,
+  writeUpdateCache,
+} from "../updates.js";
+
+const CLI_BIN = fileURLToPath(new URL("../../bin/impel.js", import.meta.url));
+
+const HELP = `impel update - update everything Impel in one command
+
+Reinstalls impel-cli from npm, then cascades with the NEW build:
+\`impel app update all\` (update the platform's vendor apps and managed app
+profiles) when Impel apps are installed, then \`impel skills sync all\` across
+every managed profile.
+
+Usage:
+  impel update              Update the CLI, then cascade to apps and skills
+  impel update --check      Report whether an update is available; change nothing
+  impel update --skip-apps  Skip the desktop-app step of the cascade
+`;
+
+function reportProcessFailure(stage, result) {
+  if (result?.error) {
+    console.error(`impel update: ${stage} could not start (${redactSecretText(result.error.message || result.error)}).`);
+  } else if (Number.isInteger(result?.status)) {
+    console.error(`impel update: ${stage} exited with code ${result.status}.`);
+  } else if (result?.signal) {
+    console.error(`impel update: ${stage} stopped on signal ${result.signal}.`);
+  } else {
+    console.error(`impel update: ${stage} failed without an exit status.`);
+  }
+}
+
+// npm verifies the registry tarball's integrity before replacing the global
+// package. No GitHub account or repository credential is involved.
+export function installUpdateFromRegistry(spec = updateInstallSpec(), dependencies = {}) {
+  const io = {
+    spawnSync,
+    platform: process.platform,
+    environment: process.env,
+    ...dependencies,
+  };
+  try {
+    const installInvocation = nativeCommandInvocation(
+      "npm",
+      ["install", "-g", spec],
+      io.environment,
+      io.platform,
+    );
+    const installed = io.spawnSync(installInvocation.command, installInvocation.args, {
+      stdio: "inherit",
+      env: io.environment,
+      windowsVerbatimArguments: installInvocation.windowsVerbatimArguments,
+    });
+    if (installed.status !== 0 || installed.error) {
+      reportProcessFailure("`npm install --global`", installed);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error(`impel update: npm install failed (${redactSecretText(error?.message || error)}).`);
+    return false;
+  }
+}
+
+function defaultSelfUpdate(spec) {
+  return installUpdateFromRegistry(spec);
+}
+
+// The cascading steps re-execute the (freshly installed) CLI binary so the
+// NEW code performs them, not the process that started the update.
+function defaultRunAppsUpdate() {
+  const result = spawnSync(process.execPath, [CLI_BIN, "app", "update", "all"], {
+    stdio: "inherit",
+  });
+  return result.status === 0;
+}
+
+function defaultRunSkillsSync() {
+  const result = spawnSync(process.execPath, [CLI_BIN, "skills", "sync", "all"], {
+    stdio: "inherit",
+  });
+  return result.status === 0;
+}
+
+function anyAppInstalled(homeDir = os.homedir()) {
+  const config = loadConfig();
+  const claudeUserData = process.platform === "win32"
+    ? windowsClaudeUserData(process.env, config?.tenantId || null)
+    : null;
+  const paths = appPaths(homeDir, config?.tenantId || null, { claudeUserData });
+  if (process.platform === "win32") {
+    return (
+      fs.existsSync(path.join(
+        paths.claude.userData,
+        "configLibrary",
+        `${CLAUDE_CONFIG_ID}.json`,
+      ))
+      || fs.existsSync(path.join(paths.chatgpt.codexHome, "config.toml"))
+    );
+  }
+  return (
+    fs.existsSync(paths.claude.launcher) || fs.existsSync(paths.chatgpt.launcher)
+  );
+}
+
+export async function cmdUpdate(argv, overrides = {}) {
+  const io = {
+    fetchRemoteVersion,
+    installedVersion,
+    refreshUpdateCache,
+    writeCache: writeUpdateCache,
+    selfUpdate: defaultSelfUpdate,
+    runAppsUpdate: defaultRunAppsUpdate,
+    runSkillsSync: defaultRunSkillsSync,
+    appsInstalled: anyAppInstalled,
+    platform: process.platform,
+    ...overrides,
+  };
+  const { flags } = parseFlags(argv, {
+    check: { type: "boolean" },
+    "skip-apps": { type: "boolean" },
+    "refresh-cache": { type: "boolean" },
+    help: { type: "boolean" },
+  });
+  if (flags.help) {
+    console.log(HELP);
+    return;
+  }
+  // Internal mode used by the detached launch-time check: refresh the cached
+  // registry metadata and exit silently.
+  if (flags["refresh-cache"]) {
+    await io.refreshUpdateCache();
+    return;
+  }
+
+  const current = io.installedVersion();
+  const remote = await io.fetchRemoteVersion();
+  if (remote) io.writeCache({ remoteVersion: remote, checkedAt: Date.now() });
+
+  console.log(`impel-cli v${current ?? "?"}`);
+  console.log(`npm latest: ${remote ? `v${remote}` : "unknown — registry check failed"}`);
+
+  const updateAvailable = Boolean(current && remote && isNewerVersion(remote, current));
+  const upToDate = Boolean(current && remote && !updateAvailable);
+  if (flags.check) {
+    console.log(upToDate ? "Up to date." : "Update available: run `impel update`.");
+    if (!remote) process.exitCode = 1;
+    return;
+  }
+
+  // ── CLI ────────────────────────────────────────────────────────────────
+  if (upToDate) {
+    console.log("CLI: already up to date.");
+  } else {
+    console.log("CLI: installing the latest build…");
+    if (!io.selfUpdate(updateInstallSpec())) {
+      console.error("impel update: `npm install -g` failed; the CLI was not updated.");
+      if (io.platform === "win32") {
+        console.error("  Verify `npm --version` in PowerShell, then retry `impel update`.");
+        console.error("  Manual recovery: `npm install --global impel-cli@latest`.");
+      }
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`CLI: updated${remote ? ` to v${remote}` : ""}.`);
+  }
+
+  // ── Cascade: apps, then skills across every managed profile ────────────
+  let cascadeFailed = false;
+  if (flags["skip-apps"]) {
+    console.log("Apps: skipped (--skip-apps).");
+  } else if (io.platform !== "darwin" && io.platform !== "win32") {
+    console.log("Apps: skipped — isolated desktop apps are unavailable on this platform.");
+  } else if (!io.appsInstalled()) {
+    console.log("Apps: none installed; skipping (run `impel app install` or `impel setup`).");
+  } else {
+    console.log(io.platform === "win32"
+      ? "Apps: updating the signed Claude and ChatGPT vendor apps and isolated profiles…"
+      : "Apps: updating (running apps are closed, vendor apps updated, bundles rebuilt)…");
+    if (!io.runAppsUpdate()) {
+      console.error("impel update: the app update failed; re-run `impel app update` after fixing the issue.");
+      cascadeFailed = true;
+    }
+  }
+
+  console.log("Skills: syncing every managed profile…");
+  if (!io.runSkillsSync()) {
+    console.error("impel update: skill sync failed; re-run `impel skills sync` after fixing the issue.");
+    cascadeFailed = true;
+  }
+
+  if (cascadeFailed) {
+    process.exitCode = 1;
+    return;
+  }
+  console.log("Everything is up to date.");
+}