@factorialco/fcode-cli 1.1.0

package/dist/runtime/libs/python/fcode/__init__.py

@@ -0,0 +1,75 @@
+import os
+import json
+import subprocess
+import logging
+
+YC_COMMAND = os.environ.get("YC_COMMAND", "fcode")
+
+metadata = {
+    "execution": {"process": {"name": "", "id": ""}},
+    "parameters": {},
+    "variables": [],
+}
+runtime_metadata_path = os.environ.get("FCODE_RUNTIME_METADATA_PATH", "")
+process_slug = os.environ.get("FCODE_PROCESS_SLUG", "")
+if runtime_metadata_path:
+    os.environ.get("FCODE_LOG_LEVEL", "") == "DEBUG" and print(
+        "[FCODE LIBRARY] Reading metadata from file: " + runtime_metadata_path
+    )
+    with open(runtime_metadata_path, "r") as f:
+        metadata = json.load(f)
+else:
+    process_params = os.environ.get("FCODE_PROCESS_PARAMS", "")
+    process_version = os.environ.get("FCODE_PROCESS_VERSION", "")
+    os.environ.get("FCODE_LOG_LEVEL", "") == "DEBUG" and print(
+        "[FCODE LIBRARY] Reading metadata from process-metadata command"
+    )
+    command = [YC_COMMAND, "process-metadata"]
+    if process_slug:
+        command.append(process_slug)
+        if process_slug and process_version:
+            command.append("-v")
+            command.append(process_version)
+    if process_params:
+        command.append("-p")
+        command.append(process_params)
+    os.environ.get("FCODE_LOG_LEVEL", "") == "DEBUG" and print(
+        "[FCODE LIBRARY] Running command: " + " ".join(command)
+    )
+    result = subprocess.run(command, encoding="utf-8", stdout=subprocess.PIPE)
+    if result.returncode != 0:
+        os.environ.get("FCODE_LOG_LEVEL", "") == "DEBUG" and print(
+            "[FCODE LIBRARY] Command finished with exit code: "
+            + str(result.returncode)
+        )
+        exit(1)
+    metadata = json.loads(result.stdout)
+
+from fcode.context import FcodeGlobal, Context, ExecutionInfo, Environment
+from fcode.datastore import Datastore
+from fcode.storage import Storage
+from fcode.schedule import Schedule
+from fcode.variables import Variables
+
+context = Context(metadata.get("parameters", {}))
+execution = ExecutionInfo(metadata.get("execution", {}))
+env_variables = Environment(metadata.get("variables", []))
+import builtins
+
+fcode = FcodeGlobal(
+    context,
+    execution,
+    env_variables,
+    Datastore(),
+    Storage(),
+    Schedule(),
+    Variables(env_variables),
+)
+
+logging.basicConfig(level=os.environ.get("FCODE_LOG_LEVEL", logging.INFO))
+builtins.logging = logging
+logger = logging.getLogger("fcode_logger")
+builtins.fcode = fcode
+builtins.logger = logger
+
+__all__ = ["logging", "logger", "fcode"]

package/dist/runtime/libs/python/fcode/context.py

@@ -0,0 +1,98 @@
+import sys
+import os
+
+
+class Context(dict):
+    def __init__(self, parameters):
+        self["parameters"] = parameters
+        self["request"] = "No request, you are using the CLI"
+
+    def __getattr__(self, attr):
+        return self.get(attr)
+
+
+class AttrsInfo(dict):
+    def __init__(self, attrs):
+        if attrs:
+            for key, value in attrs.items():
+                self[key] = value
+
+    def __getattr__(self, attr):
+        return self.get(attr)
+
+
+class ExecutionInfo(dict):
+    def __init__(self, parameters):
+        self["id"] = "00000000-0000-0000-0000-000000000000"
+        process = parameters.get("process", {})
+        self["process"] = AttrsInfo(
+            {
+                "id": process.get("id", "00000000-0000-0000-0000-000000000000"),
+                "name": process.get("name", "Process not yet pushed to cloud"),
+            }
+        )
+        self["timeout"] = 86400000
+
+    def __getattr__(self, attr):
+        return self.get(attr)
+
+
+class Environment(dict):
+    def __init__(self, team_variables):
+        if team_variables:
+            for key, value in team_variables.items():
+                self[key] = value
+
+    def __getattr__(self, attr):
+        return self.get(attr)
+
+
+class Processes(dict):
+    def run(self, process_identifier, options=None):
+        import subprocess
+        import json
+        import sys
+
+        if not process_identifier:
+            raise ValueError("Process identifier is required")
+
+        tag = f" -v {options['tag']}" if options and "tag" in options else ""
+        parameters = (
+            f" -p '{json.dumps(options.get('parameters', {}))}'" if options else ""
+        )
+
+        command = f"fcode run {process_identifier}{tag}{parameters}"
+        print(f"Executing command: {command}")  # Debug line
+
+        try:
+            process = subprocess.Popen(
+                command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            )
+            stdout, stderr = process.communicate()
+
+            if process.returncode != 0:
+                print(stderr.decode(), file=sys.stderr)
+            print(stdout.decode())
+            print(stderr.decode(), file=sys.stderr)
+        except Exception as error:
+            print(error, file=sys.stderr)
+
+
+class FcodeGlobal:
+    def __init__(self, context, execution, env, datastore, storage, schedule, variables):
+        self.context = context
+        self.execution = execution
+        self.team = AttrsInfo({"timezone": "UTC"})
+        self.env = env
+        self.datastore = datastore
+        self.storage = storage
+        self.schedule = schedule
+        self.variables = variables
+        self.processes = Processes()
+
+    def import_module(self, module_name, version=None):
+        module_path = module_name
+        if version:
+            module_path = os.path.join(module_path, "versions", version)
+        sys.path.append(os.path.join(os.getcwd(), "modules", module_path))
+        return __import__(module_name)

package/dist/runtime/libs/python/fcode/datastore.py

@@ -0,0 +1,35 @@
+import json
+import os
+
+
+class Datastore:
+    def save(self, datastore):
+        path = os.path.join(os.getcwd(), "datastore.json")
+        with open(path, "w") as file:
+            json.dump(datastore, file, indent=2)
+
+    def getAll(self):
+        path = os.path.join(os.getcwd(), "datastore.json")
+        try:
+            with open(path, "r") as file:
+                return json.load(file)
+        except FileNotFoundError:
+            return {}
+
+    def get(self, key):
+        if isinstance(key, (str, int)):
+            return self.getAll().get(key, None)
+        raise TypeError("Invalid argument type")
+
+    def set(self, key, value):
+        if isinstance(key, (str, int)) and isinstance(value, (str, int)):
+            datastore = self.getAll()
+            datastore[key] = value
+            self.save(datastore)
+        else:
+            raise TypeError("Invalid argument type")
+
+    def delete(self, key):
+        datastore = self.getAll()
+        datastore.pop(key, None)
+        self.save(datastore)

package/dist/runtime/libs/python/fcode/schedule.py

@@ -0,0 +1,45 @@
+import logging
+
+logger = logging.getLogger("fcode_logger")
+
+_CLOUD_ONLY = (
+    "[fcode] schedule.%s only runs in the cloud; it is a no-op during local "
+    "`fcode run`."
+)
+
+
+class Schedule:
+    """Local `fcode run` shim for `fcode.schedule`.
+
+    Scheduling is a cloud-only capability, so every method is a logged no-op
+    locally. Push the process and schedule it in the cloud to exercise it.
+    """
+
+    def create(self, process_id_or_slug, **kwargs):
+        logger.warning(_CLOUD_ONLY, "create")
+        return None
+
+    def list(self, process_id=None, keywords=None):
+        logger.warning(_CLOUD_ONLY, "list")
+        return []
+
+    def get(self, id):
+        logger.warning(_CLOUD_ONLY, "get")
+        return None
+
+    def update(self, id, **kwargs):
+        logger.warning(_CLOUD_ONLY, "update")
+        return None
+
+    def delete(self, id):
+        logger.warning(_CLOUD_ONLY, "delete")
+
+    def delete_for_process(self, process_id_or_slug):
+        logger.warning(_CLOUD_ONLY, "delete_for_process")
+        return 0
+
+    def pause(self, id):
+        logger.warning(_CLOUD_ONLY, "pause")
+
+    def resume(self, id):
+        logger.warning(_CLOUD_ONLY, "resume")

package/dist/runtime/libs/python/fcode/storage.py

@@ -0,0 +1,271 @@
+import os
+import hashlib
+import mimetypes
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+
+class SignedUrl:
+    def __init__(self, url: str, path: str, expires_at: str):
+        self.url = url
+        self.path = path
+        self.expires_at = expires_at
+
+
+class StorageObject:
+    def __init__(
+        self,
+        name: str,
+        size: int,
+        link: str,
+        md5_hash: str,
+        content_type: str,
+        created_at: str,
+        updated_at: str,
+    ):
+        self.name = name
+        self.size = size
+        self.md5_hash = md5_hash
+        self.content_type = content_type
+        self.created_at = created_at
+        self.updated_at = updated_at
+        self.link = link
+
+
+class Storage:
+    def _create_storage_object(self, filename, file_path, md5_hash):
+        try:
+            stats = os.stat(file_path)
+            current_time = datetime.utcnow().isoformat() + "Z"
+
+            content_type, _ = mimetypes.guess_type(filename)
+            if not content_type:
+                content_type = "application/octet-stream"
+
+            return StorageObject(
+                name=filename,
+                size=stats.st_size,
+                link=file_path,
+                md5_hash=md5_hash.hexdigest(),
+                content_type=content_type,
+                created_at=current_time,
+                updated_at=current_time,
+            )
+        except Exception as error:
+            raise RuntimeError(
+                f"Storage upload failed: unable to process file - {error}"
+            )
+
+    def upload(self, filename, file_obj):
+        if not isinstance(filename, str):
+            raise TypeError("Storage upload failed: filename must be a string")
+
+        if not filename.strip():
+            raise ValueError("Storage upload failed: filename cannot be empty")
+
+        if file_obj is None:
+            raise ValueError("Storage upload failed: file parameter is required")
+
+        is_file_like = hasattr(file_obj, "read")
+        is_bytes = isinstance(file_obj, bytes)
+        is_string = isinstance(file_obj, str)
+
+        if not is_file_like and not is_bytes and not is_string:
+            raise TypeError(
+                "Storage upload failed: file must be file-like object, bytes, or string"
+            )
+
+        try:
+            storage_dir = os.path.join(os.getcwd(), "storage")
+            if not os.path.exists(storage_dir):
+                os.makedirs(storage_dir, exist_ok=True)
+
+            file_path = os.path.join(storage_dir, filename)
+            file_dir = os.path.dirname(file_path)
+
+            if not os.path.exists(file_dir):
+                os.makedirs(file_dir, exist_ok=True)
+
+            md5_hash = hashlib.md5()
+
+            with open(file_path, "wb") as f:
+                if is_file_like:
+                    while chunk := file_obj.read(8192):
+                        md5_hash.update(chunk)
+                        f.write(chunk)
+                elif is_string:
+                    content = file_obj.encode("utf-8")
+                    md5_hash.update(content)
+                    f.write(content)
+                else:
+                    md5_hash.update(file_obj)
+                    f.write(file_obj)
+
+            return self._create_storage_object(filename, file_path, md5_hash)
+
+        except (OSError, IOError) as error:
+            raise RuntimeError(f"Storage upload failed: {error}")
+        except Exception as error:
+            raise RuntimeError(f"Storage upload failed: {error}")
+
+    def list(self, prefix=""):
+        if not isinstance(prefix, str):
+            raise TypeError("Storage list failed: prefix must be a string")
+
+        storage_dir = os.path.join(os.getcwd(), "storage")
+
+        if not os.path.exists(storage_dir):
+            return []
+
+        files = []
+
+        try:
+            for root, dirs, file_names in os.walk(storage_dir):
+                for file_name in file_names:
+                    full_path = os.path.join(root, file_name)
+                    relative_path = os.path.relpath(full_path, storage_dir)
+
+                    normalized_path = relative_path.replace(os.sep, "/")
+
+                    if not prefix or normalized_path.startswith(prefix):
+                        try:
+                            stats = os.stat(full_path)
+
+                            md5_hash = hashlib.md5()
+                            with open(full_path, "rb") as f:
+                                while chunk := f.read(8192):
+                                    md5_hash.update(chunk)
+
+                            content_type, _ = mimetypes.guess_type(normalized_path)
+                            if not content_type:
+                                content_type = "application/octet-stream"
+
+                            files.append(
+                                StorageObject(
+                                    name=normalized_path,
+                                    size=stats.st_size,
+                                    link=full_path,
+                                    md5_hash=md5_hash.hexdigest(),
+                                    content_type=content_type,
+                                    created_at=datetime.fromtimestamp(
+                                        stats.st_birthtime
+                                    ).isoformat()
+                                    + "Z",
+                                    updated_at=datetime.fromtimestamp(
+                                        stats.st_mtime
+                                    ).isoformat()
+                                    + "Z",
+                                )
+                            )
+                        except (OSError, IOError):
+                            print(
+                                f"Storage list warning: unable to process file {normalized_path}"
+                            )
+                            continue
+
+        except Exception as error:
+            raise RuntimeError(f"Storage list failed: {error}")
+
+        return files
+
+    def download(self, filename):
+        if not isinstance(filename, str):
+            raise TypeError("Storage download failed: filename must be a string")
+
+        if not filename.strip():
+            raise ValueError("Storage download failed: filename cannot be empty")
+
+        file_path = os.path.join(os.getcwd(), "storage", filename)
+
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(
+                f"Storage download failed: file not found - {filename}"
+            )
+
+        if not os.path.isfile(file_path):
+            raise ValueError(f"Storage download failed: {filename} is not a file")
+
+        try:
+            with open(file_path, "rb") as f:
+                return f.read()
+        except (OSError, IOError) as error:
+            raise RuntimeError(
+                f"Storage download failed: unable to read file - {error}"
+            )
+
+    def delete(self, filename):
+        if not isinstance(filename, str):
+            raise TypeError("Storage delete failed: filename must be a string")
+
+        if not filename.strip():
+            raise ValueError("Storage delete failed: filename cannot be empty")
+
+        file_path = os.path.join(os.getcwd(), "storage", filename)
+
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(
+                f"Storage delete failed: file not found - {filename}"
+            )
+
+        if not os.path.isfile(file_path):
+            raise ValueError(f"Storage delete failed: {filename} is not a file")
+
+        try:
+            os.remove(file_path)
+
+            dir_path = os.path.dirname(file_path)
+            storage_dir = os.path.join(os.getcwd(), "storage")
+
+            while dir_path != storage_dir and dir_path != os.path.dirname(dir_path):
+                try:
+                    if not os.listdir(dir_path):
+                        os.rmdir(dir_path)
+                        dir_path = os.path.dirname(dir_path)
+                    else:
+                        break
+                except OSError as error:
+                    print(
+                        f"Storage delete warning: unable to clean up directory {dir_path}: {error}"
+                    )
+                    break
+
+        except (OSError, IOError) as error:
+            raise RuntimeError(f"Storage delete failed: {error}")
+
+    def create_signed_url(self, name, expires_in_seconds=None):
+        if not isinstance(name, str):
+            raise TypeError("Storage create_signed_url failed: name must be a string")
+
+        if not name.strip():
+            raise ValueError("Storage create_signed_url failed: name cannot be empty")
+
+        if expires_in_seconds is None:
+            expires_in_seconds = 3600
+        if not isinstance(expires_in_seconds, int) or not (
+            1 <= expires_in_seconds <= 604800
+        ):
+            raise ValueError(
+                "Storage create_signed_url failed: expires_in_seconds must be an "
+                "integer between 1 and 604800"
+            )
+
+        file_path = os.path.join(os.getcwd(), "storage", name)
+
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(
+                f"Storage create_signed_url failed: file not found - {name}"
+            )
+
+        # Local runtime has no object store to sign against, so return a file://
+        # URL to the file on disk. Mirrors the cloud { url, path, expires_at }
+        # contract so process code needs no local-vs-cloud guard.
+        print(
+            "Storage create_signed_url: no object store in local runtime; "
+            "returning a file:// URL to the local file (mock)."
+        )
+
+        expires_at = (
+            datetime.now(timezone.utc) + timedelta(seconds=expires_in_seconds)
+        ).isoformat()
+
+        return SignedUrl(url=Path(file_path).as_uri(), path=name, expires_at=expires_at)

package/dist/runtime/libs/python/fcode/variables.py

@@ -0,0 +1,102 @@
+import logging
+import os
+
+logger = logging.getLogger("fcode_logger")
+
+LOCAL_VARIABLES_FILE = "variables.local.env"
+
+
+class Variables:
+    """Local `fcode run` shim for `fcode.variables`.
+
+    Reads return the team + local variables loaded for this run, overlaid with the
+    current `variables.local.env`. Writes (set/delete) affect only
+    `variables.local.env` in the workspace root, never the shared `variables.env`.
+    The `sensitive` flag has no representation in the `.env` file and is ignored
+    locally.
+    """
+
+    def __init__(self, env):
+        self._base = dict(env or {})
+
+    def _local_path(self):
+        return os.path.join(os.getcwd(), LOCAL_VARIABLES_FILE)
+
+    def _read_local(self):
+        try:
+            with open(self._local_path(), "r") as file:
+                return file.read()
+        except FileNotFoundError:
+            return ""
+
+    def _parse(self, text):
+        result = {}
+        for line in text.splitlines():
+            stripped = line.strip()
+            if not stripped or stripped.startswith("#") or "=" not in stripped:
+                continue
+            key, value = stripped.split("=", 1)
+            result[key.strip()] = value
+        return result
+
+    def _merged(self):
+        merged = dict(self._base)
+        merged.update(self._parse(self._read_local()))
+        return merged
+
+    def list(self):
+        return [{"key": key, "value": value} for key, value in self._merged().items()]
+
+    def get(self, key):
+        return self._merged().get(key)
+
+    def set(self, key, value, sensitive=True):
+        out = []
+        replaced = False
+        for line in self._read_local().splitlines():
+            stripped = line.strip()
+            if (
+                stripped
+                and not stripped.startswith("#")
+                and "=" in stripped
+                and stripped.split("=", 1)[0].strip() == key
+            ):
+                out.append(f"{key}={value}")
+                replaced = True
+            else:
+                out.append(line)
+        while out and out[-1].strip() == "":
+            out.pop()
+        if not replaced:
+            out.append(f"{key}={value}")
+        with open(self._local_path(), "w") as file:
+            file.write("\n".join(out) + "\n")
+        logger.info(
+            "[fcode] variables.set wrote %s to %s (local run).", key, LOCAL_VARIABLES_FILE
+        )
+
+    def delete(self, key):
+        text = self._read_local()
+        if not text:
+            return
+        out = []
+        for line in text.splitlines():
+            stripped = line.strip()
+            if (
+                stripped
+                and not stripped.startswith("#")
+                and "=" in stripped
+                and stripped.split("=", 1)[0].strip() == key
+            ):
+                continue
+            out.append(line)
+        while out and out[-1].strip() == "":
+            out.pop()
+        content = "\n".join(out) + "\n" if out else ""
+        with open(self._local_path(), "w") as file:
+            file.write(content)
+        logger.info(
+            "[fcode] variables.delete removed %s from %s (local run).",
+            key,
+            LOCAL_VARIABLES_FILE,
+        )

package/dist/services/auth-service.d.ts

@@ -0,0 +1,12 @@
+import type { AuthInfo, Credentials, Token, UserInfo } from '../core/types';
+import GlobalConfig from '../config/global';
+declare const AuthService: {
+    clientId: string;
+    getToken({ authUrl, email, password, clientId, clientSecret }: Credentials): Promise<Token>;
+    getUserInfo(authUrl: string, token: Token): Promise<UserInfo>;
+    globalConfig: GlobalConfig;
+    isAuthenticated(url: string): Promise<boolean>;
+    login({ url, authUrl, email, password, clientId, clientSecret, accessToken }: Credentials): Promise<AuthInfo>;
+    logout(url: string): Promise<void>;
+};
+export default AuthService;